Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-06-30
*/

// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol

pragma solidity ^0.5.2;

/**
 * @title ERC20 interface
 * @dev see https://eips.ethereum.org/EIPS/eip-20
 */
interface IERC20 {
    function transfer(address to, uint256 value) external returns (bool);

    function approve(address spender, uint256 value) external returns (bool);

    function transferFrom(address from, address to, uint256 value) external returns (bool);

    function totalSupply() external view returns (uint256);

    function balanceOf(address who) external view returns (uint256);

    function allowance(address owner, address spender) external view returns (uint256);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: openzeppelin-solidity/contracts/math/Math.sol

pragma solidity ^0.5.2;

/**
 * @title Math
 * @dev Assorted math operations
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Calculates the average of two numbers. Since these are integers,
     * averages of an even and odd number cannot be represented, and will be
     * rounded down.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}

// File: openzeppelin-solidity/contracts/math/SafeMath.sol

pragma solidity ^0.5.2;

/**
 * @title SafeMath
 * @dev Unsigned math operations with safety checks that revert on error
 */
library SafeMath {
    /**
     * @dev Multiplies two unsigned integers, reverts on overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b);

        return c;
    }

    /**
     * @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Adds two unsigned integers, reverts on overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a);

        return c;
    }

    /**
     * @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
     * reverts when dividing by zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0);
        return a % b;
    }
}

// File: openzeppelin-solidity/contracts/ownership/Ownable.sol

pragma solidity ^0.5.2;

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev The Ownable constructor sets the original `owner` of the contract to the sender
     * account.
     */
    constructor () internal {
        _owner = msg.sender;
        emit OwnershipTransferred(address(0), _owner);
    }

    /**
     * @return the address of the owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(isOwner());
        _;
    }

    /**
     * @return true if `msg.sender` is the owner of the contract.
     */
    function isOwner() public view returns (bool) {
        return msg.sender == _owner;
    }

    /**
     * @dev Allows the current owner to relinquish control of the contract.
     * It will not be possible to call the functions with the `onlyOwner`
     * modifier anymore.
     * @notice Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Allows the current owner to transfer control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0));
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: solidity-rlp/contracts/RLPReader.sol

/*
* @author Hamdi Allam [email protected]
* Please reach out with any questions or concerns
*/
pragma solidity ^0.5.0;

library RLPReader {
    uint8 constant STRING_SHORT_START = 0x80;
    uint8 constant STRING_LONG_START  = 0xb8;
    uint8 constant LIST_SHORT_START   = 0xc0;
    uint8 constant LIST_LONG_START    = 0xf8;
    uint8 constant WORD_SIZE = 32;

    struct RLPItem {
        uint len;
        uint memPtr;
    }

    struct Iterator {
        RLPItem item;   // Item that's being iterated over.
        uint nextPtr;   // Position of the next item in the list.
    }

    /*
    * @dev Returns the next element in the iteration. Reverts if it has not next element.
    * @param self The iterator.
    * @return The next element in the iteration.
    */
    function next(Iterator memory self) internal pure returns (RLPItem memory) {
        require(hasNext(self));

        uint ptr = self.nextPtr;
        uint itemLength = _itemLength(ptr);
        self.nextPtr = ptr + itemLength;

        return RLPItem(itemLength, ptr);
    }

    /*
    * @dev Returns true if the iteration has more elements.
    * @param self The iterator.
    * @return true if the iteration has more elements.
    */
    function hasNext(Iterator memory self) internal pure returns (bool) {
        RLPItem memory item = self.item;
        return self.nextPtr < item.memPtr + item.len;
    }

    /*
    * @param item RLP encoded bytes
    */
    function toRlpItem(bytes memory item) internal pure returns (RLPItem memory) {
        uint memPtr;
        assembly {
            memPtr := add(item, 0x20)
        }

        return RLPItem(item.length, memPtr);
    }

    /*
    * @dev Create an iterator. Reverts if item is not a list.
    * @param self The RLP item.
    * @return An 'Iterator' over the item.
    */
    function iterator(RLPItem memory self) internal pure returns (Iterator memory) {
        require(isList(self));

        uint ptr = self.memPtr + _payloadOffset(self.memPtr);
        return Iterator(self, ptr);
    }

    /*
    * @param item RLP encoded bytes
    */
    function rlpLen(RLPItem memory item) internal pure returns (uint) {
        return item.len;
    }

    /*
    * @param item RLP encoded bytes
    */
    function payloadLen(RLPItem memory item) internal pure returns (uint) {
        return item.len - _payloadOffset(item.memPtr);
    }

    /*
    * @param item RLP encoded list in bytes
    */
    function toList(RLPItem memory item) internal pure returns (RLPItem[] memory) {
        require(isList(item));

        uint items = numItems(item);
        RLPItem[] memory result = new RLPItem[](items);

        uint memPtr = item.memPtr + _payloadOffset(item.memPtr);
        uint dataLen;
        for (uint i = 0; i < items; i++) {
            dataLen = _itemLength(memPtr);
            result[i] = RLPItem(dataLen, memPtr); 
            memPtr = memPtr + dataLen;
        }

        return result;
    }

    // @return indicator whether encoded payload is a list. negate this function call for isData.
    function isList(RLPItem memory item) internal pure returns (bool) {
        if (item.len == 0) return false;

        uint8 byte0;
        uint memPtr = item.memPtr;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }

        if (byte0 < LIST_SHORT_START)
            return false;
        return true;
    }

    /** RLPItem conversions into data types **/

    // @returns raw rlp encoding in bytes
    function toRlpBytes(RLPItem memory item) internal pure returns (bytes memory) {
        bytes memory result = new bytes(item.len);
        if (result.length == 0) return result;
        
        uint ptr;
        assembly {
            ptr := add(0x20, result)
        }

        copy(item.memPtr, ptr, item.len);
        return result;
    }

    // any non-zero byte is considered true
    function toBoolean(RLPItem memory item) internal pure returns (bool) {
        require(item.len == 1);
        uint result;
        uint memPtr = item.memPtr;
        assembly {
            result := byte(0, mload(memPtr))
        }

        return result == 0 ? false : true;
    }

    function toAddress(RLPItem memory item) internal pure returns (address) {
        // 1 byte for the length prefix
        require(item.len == 21);

        return address(toUint(item));
    }

    function toUint(RLPItem memory item) internal pure returns (uint) {
        require(item.len > 0 && item.len <= 33);

        uint offset = _payloadOffset(item.memPtr);
        uint len = item.len - offset;

        uint result;
        uint memPtr = item.memPtr + offset;
        assembly {
            result := mload(memPtr)

            // shfit to the correct location if neccesary
            if lt(len, 32) {
                result := div(result, exp(256, sub(32, len)))
            }
        }

        return result;
    }

    // enforces 32 byte length
    function toUintStrict(RLPItem memory item) internal pure returns (uint) {
        // one byte prefix
        require(item.len == 33);

        uint result;
        uint memPtr = item.memPtr + 1;
        assembly {
            result := mload(memPtr)
        }

        return result;
    }

    function toBytes(RLPItem memory item) internal pure returns (bytes memory) {
        require(item.len > 0);

        uint offset = _payloadOffset(item.memPtr);
        uint len = item.len - offset; // data length
        bytes memory result = new bytes(len);

        uint destPtr;
        assembly {
            destPtr := add(0x20, result)
        }

        copy(item.memPtr + offset, destPtr, len);
        return result;
    }

    /*
    * Private Helpers
    */

    // @return number of payload items inside an encoded list.
    function numItems(RLPItem memory item) private pure returns (uint) {
        if (item.len == 0) return 0;

        uint count = 0;
        uint currPtr = item.memPtr + _payloadOffset(item.memPtr);
        uint endPtr = item.memPtr + item.len;
        while (currPtr < endPtr) {
           currPtr = currPtr + _itemLength(currPtr); // skip over an item
           count++;
        }

        return count;
    }

    // @return entire rlp item byte length
    function _itemLength(uint memPtr) private pure returns (uint) {
        uint itemLen;
        uint byte0;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }

        if (byte0 < STRING_SHORT_START)
            itemLen = 1;
        
        else if (byte0 < STRING_LONG_START)
            itemLen = byte0 - STRING_SHORT_START + 1;

        else if (byte0 < LIST_SHORT_START) {
            assembly {
                let byteLen := sub(byte0, 0xb7) // # of bytes the actual length is
                memPtr := add(memPtr, 1) // skip over the first byte
                
                /* 32 byte word size */
                let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen))) // right shifting to get the len
                itemLen := add(dataLen, add(byteLen, 1))
            }
        }

        else if (byte0 < LIST_LONG_START) {
            itemLen = byte0 - LIST_SHORT_START + 1;
        } 

        else {
            assembly {
                let byteLen := sub(byte0, 0xf7)
                memPtr := add(memPtr, 1)

                let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen))) // right shifting to the correct length
                itemLen := add(dataLen, add(byteLen, 1))
            }
        }

        return itemLen;
    }

    // @return number of bytes until the data
    function _payloadOffset(uint memPtr) private pure returns (uint) {
        uint byte0;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }

        if (byte0 < STRING_SHORT_START) 
            return 0;
        else if (byte0 < STRING_LONG_START || (byte0 >= LIST_SHORT_START && byte0 < LIST_LONG_START))
            return 1;
        else if (byte0 < LIST_SHORT_START)  // being explicit
            return byte0 - (STRING_LONG_START - 1) + 1;
        else
            return byte0 - (LIST_LONG_START - 1) + 1;
    }

    /*
    * @param src Pointer to source
    * @param dest Pointer to destination
    * @param len Amount of memory to copy from the source
    */
    function copy(uint src, uint dest, uint len) private pure {
        if (len == 0) return;

        // copy as many word sizes as possible
        for (; len >= WORD_SIZE; len -= WORD_SIZE) {
            assembly {
                mstore(dest, mload(src))
            }

            src += WORD_SIZE;
            dest += WORD_SIZE;
        }

        // left over bytes. Mask is used to remove unwanted bytes from the word
        uint mask = 256 ** (WORD_SIZE - len) - 1;
        assembly {
            let srcpart := and(mload(src), not(mask)) // zero out src
            let destpart := and(mload(dest), mask) // retrieve the bytes
            mstore(dest, or(destpart, srcpart))
        }
    }
}

// File: contracts/common/lib/BytesLib.sol

pragma solidity ^0.5.2;


library BytesLib {
    function concat(bytes memory _preBytes, bytes memory _postBytes)
        internal
        pure
        returns (bytes memory)
    {
        bytes memory tempBytes;
        assembly {
            // Get a location of some free memory and store it in tempBytes as
            // Solidity does for memory variables.
            tempBytes := mload(0x40)

            // Store the length of the first bytes array at the beginning of
            // the memory for tempBytes.
            let length := mload(_preBytes)
            mstore(tempBytes, length)

            // Maintain a memory counter for the current write location in the
            // temp bytes array by adding the 32 bytes for the array length to
            // the starting location.
            let mc := add(tempBytes, 0x20)
            // Stop copying when the memory counter reaches the length of the
            // first bytes array.
            let end := add(mc, length)

            for {
                // Initialize a copy counter to the start of the _preBytes data,
                // 32 bytes into its memory.
                let cc := add(_preBytes, 0x20)
            } lt(mc, end) {
                // Increase both counters by 32 bytes each iteration.
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                // Write the _preBytes data into the tempBytes memory 32 bytes
                // at a time.
                mstore(mc, mload(cc))
            }

            // Add the length of _postBytes to the current length of tempBytes
            // and store it as the new length in the first 32 bytes of the
            // tempBytes memory.
            length := mload(_postBytes)
            mstore(tempBytes, add(length, mload(tempBytes)))

            // Move the memory counter back from a multiple of 0x20 to the
            // actual end of the _preBytes data.
            mc := end
            // Stop copying when the memory counter reaches the new combined
            // length of the arrays.
            end := add(mc, length)

            for {
                let cc := add(_postBytes, 0x20)
            } lt(mc, end) {
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                mstore(mc, mload(cc))
            }

            // Update the free-memory pointer by padding our last write location
            // to 32 bytes: add 31 bytes to the end of tempBytes to move to the
            // next 32 byte block, then round down to the nearest multiple of
            // 32. If the sum of the length of the two arrays is zero then add
            // one before rounding down to leave a blank 32 bytes (the length block with 0).
            mstore(
                0x40,
                and(
                    add(add(end, iszero(add(length, mload(_preBytes)))), 31),
                    not(31) // Round down to the nearest 32 bytes.
                )
            )
        }
        return tempBytes;
    }

    function slice(bytes memory _bytes, uint256 _start, uint256 _length)
        internal
        pure
        returns (bytes memory)
    {
        require(_bytes.length >= (_start + _length));
        bytes memory tempBytes;
        assembly {
            switch iszero(_length)
                case 0 {
                    // Get a location of some free memory and store it in tempBytes as
                    // Solidity does for memory variables.
                    tempBytes := mload(0x40)

                    // The first word of the slice result is potentially a partial
                    // word read from the original array. To read it, we calculate
                    // the length of that partial word and start copying that many
                    // bytes into the array. The first word we copy will start with
                    // data we don't care about, but the last `lengthmod` bytes will
                    // land at the beginning of the contents of the new array. When
                    // we're done copying, we overwrite the full first word with
                    // the actual length of the slice.
                    let lengthmod := and(_length, 31)

                    // The multiplication in the next line is necessary
                    // because when slicing multiples of 32 bytes (lengthmod == 0)
                    // the following copy loop was copying the origin's length
                    // and then ending prematurely not copying everything it should.
                    let mc := add(
                        add(tempBytes, lengthmod),
                        mul(0x20, iszero(lengthmod))
                    )
                    let end := add(mc, _length)

                    for {
                        // The multiplication in the next line has the same exact purpose
                        // as the one above.
                        let cc := add(
                            add(
                                add(_bytes, lengthmod),
                                mul(0x20, iszero(lengthmod))
                            ),
                            _start
                        )
                    } lt(mc, end) {
                        mc := add(mc, 0x20)
                        cc := add(cc, 0x20)
                    } {
                        mstore(mc, mload(cc))
                    }

                    mstore(tempBytes, _length)

                    //update free-memory pointer
                    //allocating the array padded to 32 bytes like the compiler does now
                    mstore(0x40, and(add(mc, 31), not(31)))
                }
                //if we want a zero-length slice let's just return a zero-length array
                default {
                    tempBytes := mload(0x40)
                    mstore(0x40, add(tempBytes, 0x20))
                }
        }

        return tempBytes;
    }

    // Pad a bytes array to 32 bytes
    function leftPad(bytes memory _bytes) internal pure returns (bytes memory) {
        // may underflow if bytes.length < 32. Hence using SafeMath.sub
        bytes memory newBytes = new bytes(SafeMath.sub(32, _bytes.length));
        return concat(newBytes, _bytes);
    }

    function toBytes32(bytes memory b) internal pure returns (bytes32) {
        require(b.length >= 32, "Bytes array should atleast be 32 bytes");
        bytes32 out;
        for (uint256 i = 0; i < 32; i++) {
            out |= bytes32(b[i] & 0xFF) >> (i * 8);
        }
        return out;
    }

    function toBytes4(bytes memory b) internal pure returns (bytes4 result) {
        assembly {
            result := mload(add(b, 32))
        }
    }

    function fromBytes32(bytes32 x) internal pure returns (bytes memory) {
        bytes memory b = new bytes(32);
        for (uint256 i = 0; i < 32; i++) {
            b[i] = bytes1(uint8(uint256(x) / (2**(8 * (31 - i)))));
        }
        return b;
    }

    function fromUint(uint256 _num) internal pure returns (bytes memory _ret) {
        _ret = new bytes(32);
        assembly {
            mstore(add(_ret, 32), _num)
        }
    }

    function toUint(bytes memory _bytes, uint256 _start)
        internal
        pure
        returns (uint256)
    {
        require(_bytes.length >= (_start + 32));
        uint256 tempUint;
        assembly {
            tempUint := mload(add(add(_bytes, 0x20), _start))
        }
        return tempUint;
    }

    function toAddress(bytes memory _bytes, uint256 _start)
        internal
        pure
        returns (address)
    {
        require(_bytes.length >= (_start + 20));
        address tempAddress;
        assembly {
            tempAddress := div(
                mload(add(add(_bytes, 0x20), _start)),
                0x1000000000000000000000000
            )
        }

        return tempAddress;
    }
}

// File: contracts/common/lib/ECVerify.sol

pragma solidity ^0.5.2;


library ECVerify {
    function ecrecovery(bytes32 hash, bytes memory sig)
        public
        pure
        returns (address)
    {
        bytes32 r;
        bytes32 s;
        uint8 v;

        if (sig.length != 65) {
            return address(0x0);
        }

        assembly {
            r := mload(add(sig, 32))
            s := mload(add(sig, 64))
            v := and(mload(add(sig, 65)), 255)
        }

        // https://github.com/ethereum/go-ethereum/issues/2053
        if (v < 27) {
            v += 27;
        }

        if (v != 27 && v != 28) {
            return address(0x0);
        }

        // get address out of hash and signature
        address result = ecrecover(hash, v, r, s);

        // ecrecover returns zero on error
        require(result != address(0x0));

        return result;
    }

    function ecrecovery(bytes32 hash, uint8 v, bytes32 r, bytes32 s)
        public
        pure
        returns (address)
    {
        // get address out of hash and signature
        address result = ecrecover(hash, v, r, s);

        // ecrecover returns zero on error
        require(result != address(0x0), "signature verification failed");

        return result;
    }

    function ecverify(bytes32 hash, bytes memory sig, address signer)
        public
        pure
        returns (bool)
    {
        return signer == ecrecovery(hash, sig);
    }
}

// File: contracts/common/lib/Merkle.sol

pragma solidity ^0.5.2;

library Merkle {
    function checkMembership(
        bytes32 leaf,
        uint256 index,
        bytes32 rootHash,
        bytes memory proof
    ) public pure returns (bool) {
        require(proof.length % 32 == 0, "Invalid proof length");
        uint256 proofHeight = proof.length / 32;
        // Proof of size n means, height of the tree is n+1.
        // In a tree of height n+1, max #leafs possible is 2 ^ n
        require(index < 2 ** proofHeight, "Leaf index is too big");

        bytes32 proofElement;
        bytes32 computedHash = leaf;
        for (uint256 i = 32; i <= proof.length; i += 32) {
            assembly {
                proofElement := mload(add(proof, i))
            }

            if (index % 2 == 0) {
                computedHash = keccak256(
                    abi.encodePacked(computedHash, proofElement)
                );
            } else {
                computedHash = keccak256(
                    abi.encodePacked(proofElement, computedHash)
                );
            }

            index = index / 2;
        }
        return computedHash == rootHash;
    }
}

// File: contracts/common/governance/IGovernance.sol

pragma solidity ^0.5.2;

interface IGovernance {
    function update(address target, bytes calldata data) external;
}

// File: contracts/common/governance/Governable.sol

pragma solidity ^0.5.2;


contract Governable {
    IGovernance public governance;

    constructor(address _governance) public {
        governance = IGovernance(_governance);
    }

    modifier onlyGovernance() {
        require(
            msg.sender == address(governance),
            "Only governance contract is authorized"
        );
        _;
    }
}

// File: contracts/common/mixin/Lockable.sol

pragma solidity ^0.5.2;

contract Lockable {
    bool public locked;

    modifier onlyWhenUnlocked() {
        _assertUnlocked();
        _;
    }

    function _assertUnlocked() private view {
        require(!locked, "locked");
    }

    function lock() public {
        locked = true;
    }

    function unlock() public {
        locked = false;
    }
}

// File: contracts/common/mixin/GovernanceLockable.sol

pragma solidity ^0.5.2;



contract GovernanceLockable is Lockable, Governable {
    constructor(address governance) public Governable(governance) {}

    function lock() public onlyGovernance {
        super.lock();
    }

    function unlock() public onlyGovernance {
        super.unlock();
    }
}

// File: contracts/common/mixin/RootChainable.sol

pragma solidity ^0.5.2;


/**
 * @title RootChainable
 */
contract RootChainable is Ownable {
    address public rootChain;

    // Rootchain changed
    event RootChainChanged(
        address indexed previousRootChain,
        address indexed newRootChain
    );

    //
    // Only root chain
    //

    // only root chain
    modifier onlyRootChain() {
        require(msg.sender == rootChain);
        _;
    }

    /**
   * @dev Allows the current owner to change root chain address.
   * @param newRootChain The address to new rootchain.
   */
    function changeRootChain(address newRootChain) public onlyOwner {
        require(newRootChain != address(0));
        emit RootChainChanged(rootChain, newRootChain);
        rootChain = newRootChain;
    }
}

// File: contracts/root/withdrawManager/IWithdrawManager.sol

pragma solidity ^0.5.2;

contract IWithdrawManager {
    function createExitQueue(address token) external;

    function verifyInclusion(
        bytes calldata data,
        uint8 offset,
        bool verifyTxInclusion
    ) external view returns (uint256 age);

    function addExitToQueue(
        address exitor,
        address childToken,
        address rootToken,
        uint256 exitAmountOrTokenId,
        bytes32 txHash,
        bool isRegularExit,
        uint256 priority
    ) external;

    function addInput(
        uint256 exitId,
        uint256 age,
        address utxoOwner,
        address token
    ) external;

    function challengeExit(
        uint256 exitId,
        uint256 inputId,
        bytes calldata challengeData,
        address adjudicatorPredicate
    ) external;
}

// File: contracts/common/Registry.sol

pragma solidity ^0.5.2;




contract Registry is Governable {
    // @todo hardcode constants
    bytes32 private constant WETH_TOKEN = keccak256("wethToken");
    bytes32 private constant DEPOSIT_MANAGER = keccak256("depositManager");
    bytes32 private constant STAKE_MANAGER = keccak256("stakeManager");
    bytes32 private constant VALIDATOR_SHARE = keccak256("validatorShare");
    bytes32 private constant WITHDRAW_MANAGER = keccak256("withdrawManager");
    bytes32 private constant CHILD_CHAIN = keccak256("childChain");
    bytes32 private constant STATE_SENDER = keccak256("stateSender");
    bytes32 private constant SLASHING_MANAGER = keccak256("slashingManager");

    address public erc20Predicate;
    address public erc721Predicate;

    mapping(bytes32 => address) public contractMap;
    mapping(address => address) public rootToChildToken;
    mapping(address => address) public childToRootToken;
    mapping(address => bool) public proofValidatorContracts;
    mapping(address => bool) public isERC721;

    enum Type {Invalid, ERC20, ERC721, Custom}
    struct Predicate {
        Type _type;
    }
    mapping(address => Predicate) public predicates;

    event TokenMapped(address indexed rootToken, address indexed childToken);
    event ProofValidatorAdded(address indexed validator, address indexed from);
    event ProofValidatorRemoved(address indexed validator, address indexed from);
    event PredicateAdded(address indexed predicate, address indexed from);
    event PredicateRemoved(address indexed predicate, address indexed from);
    event ContractMapUpdated(bytes32 indexed key, address indexed previousContract, address indexed newContract);

    constructor(address _governance) public Governable(_governance) {}

    function updateContractMap(bytes32 _key, address _address) external onlyGovernance {
        emit ContractMapUpdated(_key, contractMap[_key], _address);
        contractMap[_key] = _address;
    }

    /**
     * @dev Map root token to child token
     * @param _rootToken Token address on the root chain
     * @param _childToken Token address on the child chain
     * @param _isERC721 Is the token being mapped ERC721
     */
    function mapToken(
        address _rootToken,
        address _childToken,
        bool _isERC721
    ) external onlyGovernance {
        require(_rootToken != address(0x0) && _childToken != address(0x0), "INVALID_TOKEN_ADDRESS");
        rootToChildToken[_rootToken] = _childToken;
        childToRootToken[_childToken] = _rootToken;
        isERC721[_rootToken] = _isERC721;
        IWithdrawManager(contractMap[WITHDRAW_MANAGER]).createExitQueue(_rootToken);
        emit TokenMapped(_rootToken, _childToken);
    }

    function addErc20Predicate(address predicate) public onlyGovernance {
        require(predicate != address(0x0), "Can not add null address as predicate");
        erc20Predicate = predicate;
        addPredicate(predicate, Type.ERC20);
    }

    function addErc721Predicate(address predicate) public onlyGovernance {
        erc721Predicate = predicate;
        addPredicate(predicate, Type.ERC721);
    }

    function addPredicate(address predicate, Type _type) public onlyGovernance {
        require(predicates[predicate]._type == Type.Invalid, "Predicate already added");
        predicates[predicate]._type = _type;
        emit PredicateAdded(predicate, msg.sender);
    }

    function removePredicate(address predicate) public onlyGovernance {
        require(predicates[predicate]._type != Type.Invalid, "Predicate does not exist");
        delete predicates[predicate];
        emit PredicateRemoved(predicate, msg.sender);
    }

    function getValidatorShareAddress() public view returns (address) {
        return contractMap[VALIDATOR_SHARE];
    }

    function getWethTokenAddress() public view returns (address) {
        return contractMap[WETH_TOKEN];
    }

    function getDepositManagerAddress() public view returns (address) {
        return contractMap[DEPOSIT_MANAGER];
    }

    function getStakeManagerAddress() public view returns (address) {
        return contractMap[STAKE_MANAGER];
    }

    function getSlashingManagerAddress() public view returns (address) {
        return contractMap[SLASHING_MANAGER];
    }

    function getWithdrawManagerAddress() public view returns (address) {
        return contractMap[WITHDRAW_MANAGER];
    }

    function getChildChainAndStateSender() public view returns (address, address) {
        return (contractMap[CHILD_CHAIN], contractMap[STATE_SENDER]);
    }

    function isTokenMapped(address _token) public view returns (bool) {
        return rootToChildToken[_token] != address(0x0);
    }

    function isTokenMappedAndIsErc721(address _token) public view returns (bool) {
        require(isTokenMapped(_token), "TOKEN_NOT_MAPPED");
        return isERC721[_token];
    }

    function isTokenMappedAndGetPredicate(address _token) public view returns (address) {
        if (isTokenMappedAndIsErc721(_token)) {
            return erc721Predicate;
        }
        return erc20Predicate;
    }

    function isChildTokenErc721(address childToken) public view returns (bool) {
        address rootToken = childToRootToken[childToken];
        require(rootToken != address(0x0), "Child token is not mapped");
        return isERC721[rootToken];
    }
}

// File: contracts/staking/stakeManager/IStakeManager.sol

pragma solidity ^0.5.2;


contract IStakeManager {
    // validator replacement
    function startAuction(
        uint256 validatorId,
        uint256 amount,
        bool acceptDelegation,
        bytes calldata signerPubkey
    ) external;

    function confirmAuctionBid(uint256 validatorId, uint256 heimdallFee) external;

    function transferFunds(
        uint256 validatorId,
        uint256 amount,
        address delegator
    ) external returns (bool);

    function delegationDeposit(
        uint256 validatorId,
        uint256 amount,
        address delegator
    ) external returns (bool);

    function stake(
        uint256 amount,
        uint256 heimdallFee,
        bool acceptDelegation,
        bytes calldata signerPubkey
    ) external;

    function unstake(uint256 validatorId) external;

    function totalStakedFor(address addr) external view returns (uint256);

    function stakeFor(
        address user,
        uint256 amount,
        uint256 heimdallFee,
        bool acceptDelegation,
        bytes memory signerPubkey
    ) public;

    function checkSignatures(
        uint256 blockInterval,
        bytes32 voteHash,
        bytes32 stateRoot,
        address proposer,
        bytes memory sigs
    ) public returns (uint256);

    function updateValidatorState(uint256 validatorId, int256 amount) public;

    function ownerOf(uint256 tokenId) public view returns (address);

    function slash(bytes memory slashingInfoList) public returns (uint256);

    function validatorStake(uint256 validatorId) public view returns (uint256);

    function epoch() public view returns (uint256);

    function withdrawalDelay() public view returns (uint256);
}

// File: contracts/staking/validatorShare/IValidatorShare.sol

pragma solidity ^0.5.2;

// note this contract interface is only for stakeManager use
contract IValidatorShare {
    function withdrawRewardsValidator() external returns (uint256);

    function addProposerBonus(uint256 _rewards, uint256 valStake) public;

    function withdrawRewards() public;

    function unstakeClaimTokens() public;

    function getLiquidRewards(address user) public view returns (uint256);
    
    function getActiveAmount() external view returns (uint256);

    function owner() public view returns (address);

    function restake() public;

    function updateRewards(
        uint256 _reward,
        uint256 _totalStake,
        uint256 validatorStake
    ) external returns (uint256);

    function unlockContract() external returns (uint256);

    function lockContract() external returns (uint256);

    function drain(
        address token,
        address payable destination,
        uint256 amount
    ) external;

    function slash(uint256 valPow, uint256 totalAmountToSlash) external returns (uint256);

    function updateDelegation(bool delegation) external;
}

// File: contracts/staking/StakingInfo.sol

pragma solidity ^0.5.2;







// dummy interface to avoid cyclic dependency
contract IStakeManagerLocal {
    enum Status {Inactive, Active, Locked, Unstaked}

    struct Validator {
        uint256 amount;
        uint256 reward;
        uint256 activationEpoch;
        uint256 deactivationEpoch;
        uint256 jailTime;
        address signer;
        address contractAddress;
        Status status;
    }

    mapping(uint256 => Validator) public validators;
    bytes32 public accountStateRoot;
    uint256 public activeAmount; // delegation amount from validator contract
    uint256 public validatorRewards;

    function currentValidatorSetTotalStake() public view returns (uint256);

    // signer to Validator mapping
    function signerToValidator(address validatorAddress)
        public
        view
        returns (uint256);

    function isValidator(uint256 validatorId) public view returns (bool);
}


contract StakingInfo is Ownable {
    using SafeMath for uint256;
    mapping(uint256 => uint256) public validatorNonce;

    /// @dev Emitted when validator stakes in '_stakeFor()' in StakeManager.
    /// @param signer validator address.
    /// @param validatorId unique integer to identify a validator.
    /// @param nonce to synchronize the events in heimdal.
    /// @param activationEpoch validator's first epoch as proposer.
    /// @param amount staking amount.
    /// @param total total staking amount.
    /// @param signerPubkey public key of the validator
    event Staked(
        address indexed signer,
        uint256 indexed validatorId,
        uint256 nonce,
        uint256 indexed activationEpoch,
        uint256 amount,
        uint256 total,
        bytes signerPubkey
    );

    /// @dev Emitted when validator unstakes in 'unstakeClaim()'
    /// @param user address of the validator.
    /// @param validatorId unique integer to identify a validator.
    /// @param amount staking amount.
    /// @param total total staking amount.
    event Unstaked(
        address indexed user,
        uint256 indexed validatorId,
        uint256 amount,
        uint256 total
    );

    /// @dev Emitted when validator unstakes in '_unstake()'.
    /// @param user address of the validator.
    /// @param validatorId unique integer to identify a validator.
    /// @param nonce to synchronize the events in heimdal.
    /// @param deactivationEpoch last epoch for validator.
    /// @param amount staking amount.
    event UnstakeInit(
        address indexed user,
        uint256 indexed validatorId,
        uint256 nonce,
        uint256 deactivationEpoch,
        uint256 indexed amount
    );

    /// @dev Emitted when the validator public key is updated in 'updateSigner()'.
    /// @param validatorId unique integer to identify a validator.
    /// @param nonce to synchronize the events in heimdal.
    /// @param oldSigner old address of the validator.
    /// @param newSigner new address of the validator.
    /// @param signerPubkey public key of the validator.
    event SignerChange(
        uint256 indexed validatorId,
        uint256 nonce,
        address indexed oldSigner,
        address indexed newSigner,
        bytes signerPubkey
    );
    event Restaked(uint256 indexed validatorId, uint256 amount, uint256 total);
    event Jailed(
        uint256 indexed validatorId,
        uint256 indexed exitEpoch,
        address indexed signer
    );
    event UnJailed(uint256 indexed validatorId, address indexed signer);
    event Slashed(uint256 indexed nonce, uint256 indexed amount);
    event ThresholdChange(uint256 newThreshold, uint256 oldThreshold);
    event DynastyValueChange(uint256 newDynasty, uint256 oldDynasty);
    event ProposerBonusChange(
        uint256 newProposerBonus,
        uint256 oldProposerBonus
    );

    event RewardUpdate(uint256 newReward, uint256 oldReward);

    /// @dev Emitted when validator confirms the auction bid and at the time of restaking in confirmAuctionBid() and restake().
    /// @param validatorId unique integer to identify a validator.
    /// @param nonce to synchronize the events in heimdal.
    /// @param newAmount the updated stake amount.
    event StakeUpdate(
        uint256 indexed validatorId,
        uint256 indexed nonce,
        uint256 indexed newAmount
    );
    event ClaimRewards(
        uint256 indexed validatorId,
        uint256 indexed amount,
        uint256 indexed totalAmount
    );
    event StartAuction(
        uint256 indexed validatorId,
        uint256 indexed amount,
        uint256 indexed auctionAmount
    );
    event ConfirmAuction(
        uint256 indexed newValidatorId,
        uint256 indexed oldValidatorId,
        uint256 indexed amount
    );
    event TopUpFee(address indexed user, uint256 indexed fee);
    event ClaimFee(address indexed user, uint256 indexed fee);
    // Delegator events
    event ShareMinted(
        uint256 indexed validatorId,
        address indexed user,
        uint256 indexed amount,
        uint256 tokens
    );
    event ShareBurned(
        uint256 indexed validatorId,
        address indexed user,
        uint256 indexed amount,
        uint256 tokens
    );
    event DelegatorClaimedRewards(
        uint256 indexed validatorId,
        address indexed user,
        uint256 indexed rewards
    );
    event DelegatorRestaked(
        uint256 indexed validatorId,
        address indexed user,
        uint256 indexed totalStaked
    );
    event DelegatorUnstaked(
        uint256 indexed validatorId,
        address indexed user,
        uint256 amount
    );
    event UpdateCommissionRate(
        uint256 indexed validatorId,
        uint256 indexed newCommissionRate,
        uint256 indexed oldCommissionRate
    );

    Registry public registry;

    modifier onlyValidatorContract(uint256 validatorId) {
        address _contract;
        (, , , , , , _contract, ) = IStakeManagerLocal(
            registry.getStakeManagerAddress()
        )
            .validators(validatorId);
        require(_contract == msg.sender,
        "Invalid sender, not validator");
        _;
    }

    modifier StakeManagerOrValidatorContract(uint256 validatorId) {
        address _contract;
        address _stakeManager = registry.getStakeManagerAddress();
        (, , , , , , _contract, ) = IStakeManagerLocal(_stakeManager).validators(
            validatorId
        );
        require(_contract == msg.sender || _stakeManager == msg.sender,
        "Invalid sender, not stake manager or validator contract");
        _;
    }

    modifier onlyStakeManager() {
        require(registry.getStakeManagerAddress() == msg.sender,
        "Invalid sender, not stake manager");
        _;
    }
    modifier onlySlashingManager() {
        require(registry.getSlashingManagerAddress() == msg.sender,
        "Invalid sender, not slashing manager");
        _;
    }

    constructor(address _registry) public {
        registry = Registry(_registry);
    }

    function updateNonce(
        uint256[] calldata validatorIds,
        uint256[] calldata nonces
    ) external onlyOwner {
        require(validatorIds.length == nonces.length, "args length mismatch");

        for (uint256 i = 0; i < validatorIds.length; ++i) {
            validatorNonce[validatorIds[i]] = nonces[i];
        }
    } 

    function logStaked(
        address signer,
        bytes memory signerPubkey,
        uint256 validatorId,
        uint256 activationEpoch,
        uint256 amount,
        uint256 total
    ) public onlyStakeManager {
        validatorNonce[validatorId] = validatorNonce[validatorId].add(1);
        emit Staked(
            signer,
            validatorId,
            validatorNonce[validatorId],
            activationEpoch,
            amount,
            total,
            signerPubkey
        );
    }

    function logUnstaked(
        address user,
        uint256 validatorId,
        uint256 amount,
        uint256 total
    ) public onlyStakeManager {
        emit Unstaked(user, validatorId, amount, total);
    }

    function logUnstakeInit(
        address user,
        uint256 validatorId,
        uint256 deactivationEpoch,
        uint256 amount
    ) public onlyStakeManager {
        validatorNonce[validatorId] = validatorNonce[validatorId].add(1);
        emit UnstakeInit(
            user,
            validatorId,
            validatorNonce[validatorId],
            deactivationEpoch,
            amount
        );
    }

    function logSignerChange(
        uint256 validatorId,
        address oldSigner,
        address newSigner,
        bytes memory signerPubkey
    ) public onlyStakeManager {
        validatorNonce[validatorId] = validatorNonce[validatorId].add(1);
        emit SignerChange(
            validatorId,
            validatorNonce[validatorId],
            oldSigner,
            newSigner,
            signerPubkey
        );
    }

    function logRestaked(uint256 validatorId, uint256 amount, uint256 total)
        public
        onlyStakeManager
    {
        emit Restaked(validatorId, amount, total);
    }

    function logJailed(uint256 validatorId, uint256 exitEpoch, address signer)
        public
        onlyStakeManager
    {
        emit Jailed(validatorId, exitEpoch, signer);
    }

    function logUnjailed(uint256 validatorId, address signer)
        public
        onlyStakeManager
    {
        emit UnJailed(validatorId, signer);
    }

    function logSlashed(uint256 nonce, uint256 amount)
        public
        onlySlashingManager
    {
        emit Slashed(nonce, amount);
    }

    function logThresholdChange(uint256 newThreshold, uint256 oldThreshold)
        public
        onlyStakeManager
    {
        emit ThresholdChange(newThreshold, oldThreshold);
    }

    function logDynastyValueChange(uint256 newDynasty, uint256 oldDynasty)
        public
        onlyStakeManager
    {
        emit DynastyValueChange(newDynasty, oldDynasty);
    }

    function logProposerBonusChange(
        uint256 newProposerBonus,
        uint256 oldProposerBonus
    ) public onlyStakeManager {
        emit ProposerBonusChange(newProposerBonus, oldProposerBonus);
    }

    function logRewardUpdate(uint256 newReward, uint256 oldReward)
        public
        onlyStakeManager
    {
        emit RewardUpdate(newReward, oldReward);
    }

    function logStakeUpdate(uint256 validatorId)
        public
        StakeManagerOrValidatorContract(validatorId)
    {
        validatorNonce[validatorId] = validatorNonce[validatorId].add(1);
        emit StakeUpdate(
            validatorId,
            validatorNonce[validatorId],
            totalValidatorStake(validatorId)
        );
    }

    function logClaimRewards(
        uint256 validatorId,
        uint256 amount,
        uint256 totalAmount
    ) public onlyStakeManager {
        emit ClaimRewards(validatorId, amount, totalAmount);
    }

    function logStartAuction(
        uint256 validatorId,
        uint256 amount,
        uint256 auctionAmount
    ) public onlyStakeManager {
        emit StartAuction(validatorId, amount, auctionAmount);
    }

    function logConfirmAuction(
        uint256 newValidatorId,
        uint256 oldValidatorId,
        uint256 amount
    ) public onlyStakeManager {
        emit ConfirmAuction(newValidatorId, oldValidatorId, amount);
    }

    function logTopUpFee(address user, uint256 fee) public onlyStakeManager {
        emit TopUpFee(user, fee);
    }

    function logClaimFee(address user, uint256 fee) public onlyStakeManager {
        emit ClaimFee(user, fee);
    }

    function getStakerDetails(uint256 validatorId)
        public
        view
        returns (
            uint256 amount,
            uint256 reward,
            uint256 activationEpoch,
            uint256 deactivationEpoch,
            address signer,
            uint256 _status
        )
    {
        IStakeManagerLocal stakeManager = IStakeManagerLocal(
            registry.getStakeManagerAddress()
        );
        address _contract;
        IStakeManagerLocal.Status status;
        (
            amount,
            reward,
            activationEpoch,
            deactivationEpoch,
            ,
            signer,
            _contract,
            status
        ) = stakeManager.validators(validatorId);
        _status = uint256(status);
        if (_contract != address(0x0)) {
            reward += IStakeManagerLocal(_contract).validatorRewards();
        }
    }

    function totalValidatorStake(uint256 validatorId)
        public
        view
        returns (uint256 validatorStake)
    {
        address contractAddress;
        (validatorStake, , , , , , contractAddress, ) = IStakeManagerLocal(
            registry.getStakeManagerAddress()
        )
            .validators(validatorId);
        if (contractAddress != address(0x0)) {
            validatorStake += IStakeManagerLocal(contractAddress).activeAmount();
        }
    }

    function getAccountStateRoot()
        public
        view
        returns (bytes32 accountStateRoot)
    {
        accountStateRoot = IStakeManagerLocal(registry.getStakeManagerAddress())
            .accountStateRoot();
    }

    function getValidatorContractAddress(uint256 validatorId)
        public
        view
        returns (address ValidatorContract)
    {
        (, , , , , , ValidatorContract, ) = IStakeManagerLocal(
            registry.getStakeManagerAddress()
        )
            .validators(validatorId);
    }

    // validator Share contract logging func
    function logShareMinted(
        uint256 validatorId,
        address user,
        uint256 amount,
        uint256 tokens
    ) public onlyValidatorContract(validatorId) {
        emit ShareMinted(validatorId, user, amount, tokens);
    }

    function logShareBurned(
        uint256 validatorId,
        address user,
        uint256 amount,
        uint256 tokens
    ) public onlyValidatorContract(validatorId) {
        emit ShareBurned(validatorId, user, amount, tokens);
    }

    function logDelegatorClaimRewards(
        uint256 validatorId,
        address user,
        uint256 rewards
    ) public onlyValidatorContract(validatorId) {
        emit DelegatorClaimedRewards(validatorId, user, rewards);
    }

    function logDelegatorRestaked(
        uint256 validatorId,
        address user,
        uint256 totalStaked
    ) public onlyValidatorContract(validatorId) {
        emit DelegatorRestaked(validatorId, user, totalStaked);
    }

    function logDelegatorUnstaked(uint256 validatorId, address user, uint256 amount)
        public
        onlyValidatorContract(validatorId)
    {
        emit DelegatorUnstaked(validatorId, user, amount);
    }

    function logUpdateCommissionRate(
        uint256 validatorId,
        uint256 newCommissionRate,
        uint256 oldCommissionRate
    ) public onlyValidatorContract(validatorId) {
        emit UpdateCommissionRate(
            validatorId,
            newCommissionRate,
            oldCommissionRate
        );
    }
}

// File: openzeppelin-solidity/contracts/introspection/IERC165.sol

pragma solidity ^0.5.2;

/**
 * @title IERC165
 * @dev https://eips.ethereum.org/EIPS/eip-165
 */
interface IERC165 {
    /**
     * @notice Query if a contract implements an interface
     * @param interfaceId The interface identifier, as specified in ERC-165
     * @dev Interface identification is specified in ERC-165. This function
     * uses less than 30,000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: openzeppelin-solidity/contracts/token/ERC721/IERC721.sol

pragma solidity ^0.5.2;


/**
 * @title ERC721 Non-Fungible Token Standard basic interface
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
contract IERC721 is IERC165 {
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    function balanceOf(address owner) public view returns (uint256 balance);
    function ownerOf(uint256 tokenId) public view returns (address owner);

    function approve(address to, uint256 tokenId) public;
    function getApproved(uint256 tokenId) public view returns (address operator);

    function setApprovalForAll(address operator, bool _approved) public;
    function isApprovedForAll(address owner, address operator) public view returns (bool);

    function transferFrom(address from, address to, uint256 tokenId) public;
    function safeTransferFrom(address from, address to, uint256 tokenId) public;

    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}

// File: openzeppelin-solidity/contracts/token/ERC721/IERC721Receiver.sol

pragma solidity ^0.5.2;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
contract IERC721Receiver {
    /**
     * @notice Handle the receipt of an NFT
     * @dev The ERC721 smart contract calls this function on the recipient
     * after a `safeTransfer`. This function MUST return the function selector,
     * otherwise the caller will revert the transaction. The selector to be
     * returned can be obtained as `this.onERC721Received.selector`. This
     * function MAY throw to revert and reject the transfer.
     * Note: the ERC721 contract address is always the message sender.
     * @param operator The address which called `safeTransferFrom` function
     * @param from The address which previously owned the token
     * @param tokenId The NFT identifier which is being transferred
     * @param data Additional data with no specified format
     * @return bytes4 `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
     */
    function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
    public returns (bytes4);
}

// File: openzeppelin-solidity/contracts/utils/Address.sol

pragma solidity ^0.5.2;

/**
 * Utility library of inline functions on addresses
 */
library Address {
    /**
     * Returns whether the target address is a contract
     * @dev This function will return false if invoked during the constructor of a contract,
     * as the code is not actually created until after the constructor finishes.
     * @param account address of the account to check
     * @return whether the target address is a contract
     */
    function isContract(address account) internal view returns (bool) {
        uint256 size;
        // XXX Currently there is no better way to check if there is a contract in an address
        // than to check the size of the code at that address.
        // See https://ethereum.stackexchange.com/a/14016/36603
        // for more details about how this works.
        // TODO Check this again before the Serenity release, because all addresses will be
        // contracts then.
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }
}

// File: openzeppelin-solidity/contracts/drafts/Counters.sol

pragma solidity ^0.5.2;


/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids
 *
 * Include with `using Counters for Counters.Counter;`
 * Since it is not possible to overflow a 256 bit integer with increments of one, `increment` can skip the SafeMath
 * overflow check, thereby saving gas. This does assume however correct usage, in that the underlying `_value` is never
 * directly accessed.
 */
library Counters {
    using SafeMath for uint256;

    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        counter._value += 1;
    }

    function decrement(Counter storage counter) internal {
        counter._value = counter._value.sub(1);
    }
}

// File: openzeppelin-solidity/contracts/introspection/ERC165.sol

pragma solidity ^0.5.2;


/**
 * @title ERC165
 * @author Matt Condon (@shrugs)
 * @dev Implements ERC165 using a lookup table.
 */
contract ERC165 is IERC165 {
    bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
    /*
     * 0x01ffc9a7 ===
     *     bytes4(keccak256('supportsInterface(bytes4)'))
     */

    /**
     * @dev a mapping of interface id to whether or not it's supported
     */
    mapping(bytes4 => bool) private _supportedInterfaces;

    /**
     * @dev A contract implementing SupportsInterfaceWithLookup
     * implement ERC165 itself
     */
    constructor () internal {
        _registerInterface(_INTERFACE_ID_ERC165);
    }

    /**
     * @dev implement supportsInterface(bytes4) using a lookup table
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool) {
        return _supportedInterfaces[interfaceId];
    }

    /**
     * @dev internal method for registering an interface
     */
    function _registerInterface(bytes4 interfaceId) internal {
        require(interfaceId != 0xffffffff);
        _supportedInterfaces[interfaceId] = true;
    }
}

// File: openzeppelin-solidity/contracts/token/ERC721/ERC721.sol

pragma solidity ^0.5.2;







/**
 * @title ERC721 Non-Fungible Token Standard basic implementation
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
contract ERC721 is ERC165, IERC721 {
    using SafeMath for uint256;
    using Address for address;
    using Counters for Counters.Counter;

    // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
    // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
    bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;

    // Mapping from token ID to owner
    mapping (uint256 => address) private _tokenOwner;

    // Mapping from token ID to approved address
    mapping (uint256 => address) private _tokenApprovals;

    // Mapping from owner to number of owned token
    mapping (address => Counters.Counter) private _ownedTokensCount;

    // Mapping from owner to operator approvals
    mapping (address => mapping (address => bool)) private _operatorApprovals;

    bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
    /*
     * 0x80ac58cd ===
     *     bytes4(keccak256('balanceOf(address)')) ^
     *     bytes4(keccak256('ownerOf(uint256)')) ^
     *     bytes4(keccak256('approve(address,uint256)')) ^
     *     bytes4(keccak256('getApproved(uint256)')) ^
     *     bytes4(keccak256('setApprovalForAll(address,bool)')) ^
     *     bytes4(keccak256('isApprovedForAll(address,address)')) ^
     *     bytes4(keccak256('transferFrom(address,address,uint256)')) ^
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256)')) ^
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)'))
     */

    constructor () public {
        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(_INTERFACE_ID_ERC721);
    }

    /**
     * @dev Gets the balance of the specified address
     * @param owner address to query the balance of
     * @return uint256 representing the amount owned by the passed address
     */
    function balanceOf(address owner) public view returns (uint256) {
        require(owner != address(0));
        return _ownedTokensCount[owner].current();
    }

    /**
     * @dev Gets the owner of the specified token ID
     * @param tokenId uint256 ID of the token to query the owner of
     * @return address currently marked as the owner of the given token ID
     */
    function ownerOf(uint256 tokenId) public view returns (address) {
        address owner = _tokenOwner[tokenId];
        require(owner != address(0));
        return owner;
    }

    /**
     * @dev Approves another address to transfer the given token ID
     * The zero address indicates there is no approved address.
     * There can only be one approved address per token at a given time.
     * Can only be called by the token owner or an approved operator.
     * @param to address to be approved for the given token ID
     * @param tokenId uint256 ID of the token to be approved
     */
    function approve(address to, uint256 tokenId) public {
        address owner = ownerOf(tokenId);
        require(to != owner);
        require(msg.sender == owner || isApprovedForAll(owner, msg.sender));

        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

    /**
     * @dev Gets the approved address for a token ID, or zero if no address set
     * Reverts if the token ID does not exist.
     * @param tokenId uint256 ID of the token to query the approval of
     * @return address currently approved for the given token ID
     */
    function getApproved(uint256 tokenId) public view returns (address) {
        require(_exists(tokenId));
        return _tokenApprovals[tokenId];
    }

    /**
     * @dev Sets or unsets the approval of a given operator
     * An operator is allowed to transfer all tokens of the sender on their behalf
     * @param to operator address to set the approval
     * @param approved representing the status of the approval to be set
     */
    function setApprovalForAll(address to, bool approved) public {
        require(to != msg.sender);
        _operatorApprovals[msg.sender][to] = approved;
        emit ApprovalForAll(msg.sender, to, approved);
    }

    /**
     * @dev Tells whether an operator is approved by a given owner
     * @param owner owner address which you want to query the approval of
     * @param operator operator address which you want to query the approval of
     * @return bool whether the given operator is approved by the given owner
     */
    function isApprovedForAll(address owner, address operator) public view returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev Transfers the ownership of a given token ID to another address
     * Usage of this method is discouraged, use `safeTransferFrom` whenever possible
     * Requires the msg.sender to be the owner, approved, or operator
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     */
    function transferFrom(address from, address to, uint256 tokenId) public {
        require(_isApprovedOrOwner(msg.sender, tokenId));

        _transferFrom(from, to, tokenId);
    }

    /**
     * @dev Safely transfers the ownership of a given token ID to another address
     * If the target address is a contract, it must implement `onERC721Received`,
     * which is called upon a safe transfer, and return the magic value
     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
     * the transfer is reverted.
     * Requires the msg.sender to be the owner, approved, or operator
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev Safely transfers the ownership of a given token ID to another address
     * If the target address is a contract, it must implement `onERC721Received`,
     * which is called upon a safe transfer, and return the magic value
     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
     * the transfer is reverted.
     * Requires the msg.sender to be the owner, approved, or operator
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes data to send along with a safe transfer check
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
        transferFrom(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data));
    }

    /**
     * @dev Returns whether the specified token exists
     * @param tokenId uint256 ID of the token to query the existence of
     * @return bool whether the token exists
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        address owner = _tokenOwner[tokenId];
        return owner != address(0);
    }

    /**
     * @dev Returns whether the given spender can transfer a given token ID
     * @param spender address of the spender to query
     * @param tokenId uint256 ID of the token to be transferred
     * @return bool whether the msg.sender is approved for the given token ID,
     * is an operator of the owner, or is the owner of the token
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
        address owner = ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /**
     * @dev Internal function to mint a new token
     * Reverts if the given token ID already exists
     * @param to The address that will own the minted token
     * @param tokenId uint256 ID of the token to be minted
     */
    function _mint(address to, uint256 tokenId) internal {
        require(to != address(0));
        require(!_exists(tokenId));

        _tokenOwner[tokenId] = to;
        _ownedTokensCount[to].increment();

        emit Transfer(address(0), to, tokenId);
    }

    /**
     * @dev Internal function to burn a specific token
     * Reverts if the token does not exist
     * Deprecated, use _burn(uint256) instead.
     * @param owner owner of the token to burn
     * @param tokenId uint256 ID of the token being burned
     */
    function _burn(address owner, uint256 tokenId) internal {
        require(ownerOf(tokenId) == owner);

        _clearApproval(tokenId);

        _ownedTokensCount[owner].decrement();
        _tokenOwner[tokenId] = address(0);

        emit Transfer(owner, address(0), tokenId);
    }

    /**
     * @dev Internal function to burn a specific token
     * Reverts if the token does not exist
     * @param tokenId uint256 ID of the token being burned
     */
    function _burn(uint256 tokenId) internal {
        _burn(ownerOf(tokenId), tokenId);
    }

    /**
     * @dev Internal function to transfer ownership of a given token ID to another address.
     * As opposed to transferFrom, this imposes no restrictions on msg.sender.
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     */
    function _transferFrom(address from, address to, uint256 tokenId) internal {
        require(ownerOf(tokenId) == from);
        require(to != address(0));

        _clearApproval(tokenId);

        _ownedTokensCount[from].decrement();
        _ownedTokensCount[to].increment();

        _tokenOwner[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Internal function to invoke `onERC721Received` on a target address
     * The call is not executed if the target address is not a contract
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
        internal returns (bool)
    {
        if (!to.isContract()) {
            return true;
        }

        bytes4 retval = IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, _data);
        return (retval == _ERC721_RECEIVED);
    }

    /**
     * @dev Private function to clear current approval of a given token ID
     * @param tokenId uint256 ID of the token to be transferred
     */
    function _clearApproval(uint256 tokenId) private {
        if (_tokenApprovals[tokenId] != address(0)) {
            _tokenApprovals[tokenId] = address(0);
        }
    }
}

// File: openzeppelin-solidity/contracts/token/ERC721/IERC721Enumerable.sol

pragma solidity ^0.5.2;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
contract IERC721Enumerable is IERC721 {
    function totalSupply() public view returns (uint256);
    function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);

    function tokenByIndex(uint256 index) public view returns (uint256);
}

// File: openzeppelin-solidity/contracts/token/ERC721/ERC721Enumerable.sol

pragma solidity ^0.5.2;




/**
 * @title ERC-721 Non-Fungible Token with optional enumeration extension logic
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => uint256[]) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

    bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
    /*
     * 0x780e9d63 ===
     *     bytes4(keccak256('totalSupply()')) ^
     *     bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
     *     bytes4(keccak256('tokenByIndex(uint256)'))
     */

    /**
     * @dev Constructor function
     */
    constructor () public {
        // register the supported interface to conform to ERC721Enumerable via ERC165
        _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
    }

    /**
     * @dev Gets the token ID at a given index of the tokens list of the requested owner
     * @param owner address owning the tokens list to be accessed
     * @param index uint256 representing the index to be accessed of the requested tokens list
     * @return uint256 token ID at the given index of the tokens list owned by the requested address
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
        require(index < balanceOf(owner));
        return _ownedTokens[owner][index];
    }

    /**
     * @dev Gets the total amount of tokens stored by the contract
     * @return uint256 representing the total amount of tokens
     */
    function totalSupply() public view returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev Gets the token ID at a given index of all the tokens in this contract
     * Reverts if the index is greater or equal to the total number of tokens
     * @param index uint256 representing the index to be accessed of the tokens list
     * @return uint256 token ID at the given index of the tokens list
     */
    function tokenByIndex(uint256 index) public view returns (uint256) {
        require(index < totalSupply());
        return _allTokens[index];
    }

    /**
     * @dev Internal function to transfer ownership of a given token ID to another address.
     * As opposed to transferFrom, this imposes no restrictions on msg.sender.
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     */
    function _transferFrom(address from, address to, uint256 tokenId) internal {
        super._transferFrom(from, to, tokenId);

        _removeTokenFromOwnerEnumeration(from, tokenId);

        _addTokenToOwnerEnumeration(to, tokenId);
    }

    /**
     * @dev Internal function to mint a new token
     * Reverts if the given token ID already exists
     * @param to address the beneficiary that will own the minted token
     * @param tokenId uint256 ID of the token to be minted
     */
    function _mint(address to, uint256 tokenId) internal {
        super._mint(to, tokenId);

        _addTokenToOwnerEnumeration(to, tokenId);

        _addTokenToAllTokensEnumeration(tokenId);
    }

    /**
     * @dev Internal function to burn a specific token
     * Reverts if the token does not exist
     * Deprecated, use _burn(uint256) instead
     * @param owner owner of the token to burn
     * @param tokenId uint256 ID of the token being burned
     */
    function _burn(address owner, uint256 tokenId) internal {
        super._burn(owner, tokenId);

        _removeTokenFromOwnerEnumeration(owner, tokenId);
        // Since tokenId will be deleted, we can clear its slot in _ownedTokensIndex to trigger a gas refund
        _ownedTokensIndex[tokenId] = 0;

        _removeTokenFromAllTokensEnumeration(tokenId);
    }

    /**
     * @dev Gets the list of token IDs of the requested owner
     * @param owner address owning the tokens
     * @return uint256[] List of token IDs owned by the requested address
     */
    function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
        return _ownedTokens[owner];
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        _ownedTokensIndex[tokenId] = _ownedTokens[to].length;
        _ownedTokens[to].push(tokenId);
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the _ownedTokensIndex mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        _ownedTokens[from].length--;

        // Note that _ownedTokensIndex[tokenId] hasn't been cleared: it still points to the old slot (now occupied by
        // lastTokenId, or just over the end of the array if the token was the last one).
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length.sub(1);
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        _allTokens.length--;
        _allTokensIndex[tokenId] = 0;
    }
}

// File: openzeppelin-solidity/contracts/token/ERC721/IERC721Metadata.sol

pragma solidity ^0.5.2;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
contract IERC721Metadata is IERC721 {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// File: openzeppelin-solidity/contracts/token/ERC721/ERC721Metadata.sol

pragma solidity ^0.5.2;




contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Optional mapping for token URIs
    mapping(uint256 => string) private _tokenURIs;

    bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
    /*
     * 0x5b5e139f ===
     *     bytes4(keccak256('name()')) ^
     *     bytes4(keccak256('symbol()')) ^
     *     bytes4(keccak256('tokenURI(uint256)'))
     */

    /**
     * @dev Constructor function
     */
    constructor (string memory name, string memory symbol) public {
        _name = name;
        _symbol = symbol;

        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(_INTERFACE_ID_ERC721_METADATA);
    }

    /**
     * @dev Gets the token name
     * @return string representing the token name
     */
    function name() external view returns (string memory) {
        return _name;
    }

    /**
     * @dev Gets the token symbol
     * @return string representing the token symbol
     */
    function symbol() external view returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns an URI for a given token ID
     * Throws if the token ID does not exist. May return an empty string.
     * @param tokenId uint256 ID of the token to query
     */
    function tokenURI(uint256 tokenId) external view returns (string memory) {
        require(_exists(tokenId));
        return _tokenURIs[tokenId];
    }

    /**
     * @dev Internal function to set the token URI for a given token
     * Reverts if the token ID does not exist
     * @param tokenId uint256 ID of the token to set its URI
     * @param uri string URI to assign
     */
    function _setTokenURI(uint256 tokenId, string memory uri) internal {
        require(_exists(tokenId));
        _tokenURIs[tokenId] = uri;
    }

    /**
     * @dev Internal function to burn a specific token
     * Reverts if the token does not exist
     * Deprecated, use _burn(uint256) instead
     * @param owner owner of the token to burn
     * @param tokenId uint256 ID of the token being burned by the msg.sender
     */
    function _burn(address owner, uint256 tokenId) internal {
        super._burn(owner, tokenId);

        // Clear metadata (if any)
        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
        }
    }
}

// File: openzeppelin-solidity/contracts/token/ERC721/ERC721Full.sol

pragma solidity ^0.5.2;




/**
 * @title Full ERC721 Token
 * This implementation includes all the required and some optional functionality of the ERC721 standard
 * Moreover, it includes approve all functionality using operator terminology
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
    constructor (string memory name, string memory symbol) public ERC721Metadata(name, symbol) {
        // solhint-disable-previous-line no-empty-blocks
    }
}

// File: contracts/staking/stakeManager/StakingNFT.sol

pragma solidity ^0.5.2;




contract StakingNFT is ERC721Full, Ownable {
    constructor(string memory name, string memory symbol)
        public
        ERC721Full(name, symbol)
    {
        // solhint-disable-previous-line no-empty-blocks
    }

    function mint(address to, uint256 tokenId) public onlyOwner {
        require(
            balanceOf(to) == 0,
            "Validators MUST NOT own multiple stake position"
        );
        _mint(to, tokenId);
    }

    function burn(uint256 tokenId) public onlyOwner {
        _burn(tokenId);
    }

    function _transferFrom(address from, address to, uint256 tokenId) internal {
        require(
            balanceOf(to) == 0,
            "Validators MUST NOT own multiple stake position"
        );
        super._transferFrom(from, to, tokenId);
    }
}

// File: contracts/common/misc/ProxyStorage.sol

pragma solidity ^0.5.2;


contract ProxyStorage is Ownable {
    address internal proxyTo;
}

// File: contracts/common/misc/ERCProxy.sol

/*
 * SPDX-License-Identitifer:    MIT
 */

pragma solidity ^0.5.2;

// See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-897.md

interface ERCProxy {
    function proxyType() external pure returns (uint256 proxyTypeId);
    function implementation() external view returns (address codeAddr);
}

// File: contracts/common/misc/DelegateProxy.sol

pragma solidity ^0.5.2;



contract DelegateProxy is ERCProxy {
    function proxyType() external pure returns (uint256 proxyTypeId) {
        // Upgradeable proxy
        proxyTypeId = 2;
    }

    function implementation() external view returns (address);

    function delegatedFwd(address _dst, bytes memory _calldata) internal {
        // solium-disable-next-line security/no-inline-assembly
        assembly {
            let result := delegatecall(
                sub(gas, 10000),
                _dst,
                add(_calldata, 0x20),
                mload(_calldata),
                0,
                0
            )
            let size := returndatasize

            let ptr := mload(0x40)
            returndatacopy(ptr, 0, size)

            // revert instead of invalid() bc if the underlying call failed with invalid() it already wasted gas.
            // if the call returned error data, forward it
            switch result
                case 0 {
                    revert(ptr, size)
                }
                default {
                    return(ptr, size)
                }
        }
    }
}

// File: contracts/common/misc/UpgradableProxy.sol

pragma solidity ^0.5.2;


contract UpgradableProxy is DelegateProxy {
    event ProxyUpdated(address indexed _new, address indexed _old);
    event OwnerUpdate(address _new, address _old);

    bytes32 constant IMPLEMENTATION_SLOT = keccak256("matic.network.proxy.implementation");
    bytes32 constant OWNER_SLOT = keccak256("matic.network.proxy.owner");

    constructor(address _proxyTo) public {
        setOwner(msg.sender);
        setImplementation(_proxyTo);
    }

    function() external payable {
        // require(currentContract != 0, "If app code has not been set yet, do not call");
        // Todo: filter out some calls or handle in the end fallback
        delegatedFwd(loadImplementation(), msg.data);
    }

    modifier onlyProxyOwner() {
        require(loadOwner() == msg.sender, "NOT_OWNER");
        _;
    }

    function owner() external view returns(address) {
        return loadOwner();
    }

    function loadOwner() internal view returns(address) {
        address _owner;
        bytes32 position = OWNER_SLOT;
        assembly {
            _owner := sload(position)
        }
        return _owner;
    }

    function implementation() external view returns (address) {
        return loadImplementation();
    }

    function loadImplementation() internal view returns(address) {
        address _impl;
        bytes32 position = IMPLEMENTATION_SLOT;
        assembly {
            _impl := sload(position)
        }
        return _impl;
    }

    function transferOwnership(address newOwner) public onlyProxyOwner {
        require(newOwner != address(0), "ZERO_ADDRESS");
        emit OwnerUpdate(newOwner, loadOwner());
        setOwner(newOwner);
    }

    function setOwner(address newOwner) private {
        bytes32 position = OWNER_SLOT;
        assembly {
            sstore(position, newOwner)
        }
    }

    function updateImplementation(address _newProxyTo) public onlyProxyOwner {
        require(_newProxyTo != address(0x0), "INVALID_PROXY_ADDRESS");
        require(isContract(_newProxyTo), "DESTINATION_ADDRESS_IS_NOT_A_CONTRACT");

        emit ProxyUpdated(_newProxyTo, loadImplementation());
        
        setImplementation(_newProxyTo);
    }

    function updateAndCall(address _newProxyTo, bytes memory data) payable public onlyProxyOwner {
        updateImplementation(_newProxyTo);

        (bool success, bytes memory returnData) = address(this).call.value(msg.value)(data);
        require(success, string(returnData));
    }

    function setImplementation(address _newProxyTo) private {
        bytes32 position = IMPLEMENTATION_SLOT;
        assembly {
            sstore(position, _newProxyTo)
        }
    }
    
    function isContract(address _target) internal view returns (bool) {
        if (_target == address(0)) {
            return false;
        }

        uint256 size;
        assembly {
            size := extcodesize(_target)
        }
        return size > 0;
    }
}

// File: contracts/staking/validatorShare/ValidatorShareProxy.sol

pragma solidity ^0.5.2;



contract ValidatorShareProxy is UpgradableProxy {
    constructor(address _registry) public UpgradableProxy(_registry) {}

    function loadImplementation() internal view returns (address) {
        return Registry(super.loadImplementation()).getValidatorShareAddress();
    }
}

// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol

pragma solidity ^0.5.2;



/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * https://eips.ethereum.org/EIPS/eip-20
 * Originally based on code by FirstBlood:
 * https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
 *
 * This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
 * all accounts just by listening to said events. Note that this isn't required by the specification, and other
 * compliant implementations may not do it.
 */
contract ERC20 is IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowed;

    uint256 private _totalSupply;

    /**
     * @dev Total number of tokens in existence
     */
    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev Gets the balance of the specified address.
     * @param owner The address to query the balance of.
     * @return A uint256 representing the amount owned by the passed address.
     */
    function balanceOf(address owner) public view returns (uint256) {
        return _balances[owner];
    }

    /**
     * @dev Function to check the amount of tokens that an owner allowed to a spender.
     * @param owner address The address which owns the funds.
     * @param spender address The address which will spend the funds.
     * @return A uint256 specifying the amount of tokens still available for the spender.
     */
    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowed[owner][spender];
    }

    /**
     * @dev Transfer token to a specified address
     * @param to The address to transfer to.
     * @param value The amount to be transferred.
     */
    function transfer(address to, uint256 value) public returns (bool) {
        _transfer(msg.sender, to, value);
        return true;
    }

    /**
     * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
     * Beware that changing an allowance with this method brings the risk that someone may use both the old
     * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
     * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     */
    function approve(address spender, uint256 value) public returns (bool) {
        _approve(msg.sender, spender, value);
        return true;
    }

    /**
     * @dev Transfer tokens from one address to another.
     * Note that while this function emits an Approval event, this is not required as per the specification,
     * and other compliant implementations may not emit the event.
     * @param from address The address which you want to send tokens from
     * @param to address The address which you want to transfer to
     * @param value uint256 the amount of tokens to be transferred
     */
    function transferFrom(address from, address to, uint256 value) public returns (bool) {
        _transfer(from, to, value);
        _approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
        return true;
    }

    /**
     * @dev Increase the amount of tokens that an owner allowed to a spender.
     * approve should be called when _allowed[msg.sender][spender] == 0. To increment
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * Emits an Approval event.
     * @param spender The address which will spend the funds.
     * @param addedValue The amount of tokens to increase the allowance by.
     */
    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Decrease the amount of tokens that an owner allowed to a spender.
     * approve should be called when _allowed[msg.sender][spender] == 0. To decrement
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * Emits an Approval event.
     * @param spender The address which will spend the funds.
     * @param subtractedValue The amount of tokens to decrease the allowance by.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
        return true;
    }

    /**
     * @dev Transfer token for a specified addresses
     * @param from The address to transfer from.
     * @param to The address to transfer to.
     * @param value The amount to be transferred.
     */
    function _transfer(address from, address to, uint256 value) internal {
        require(to != address(0));

        _balances[from] = _balances[from].sub(value);
        _balances[to] = _balances[to].add(value);
        emit Transfer(from, to, value);
    }

    /**
     * @dev Internal function that mints an amount of the token and assigns it to
     * an account. This encapsulates the modification of balances such that the
     * proper events are emitted.
     * @param account The account that will receive the created tokens.
     * @param value The amount that will be created.
     */
    function _mint(address account, uint256 value) internal {
        require(account != address(0));

        _totalSupply = _totalSupply.add(value);
        _balances[account] = _balances[account].add(value);
        emit Transfer(address(0), account, value);
    }

    /**
     * @dev Internal function that burns an amount of the token of a given
     * account.
     * @param account The account whose tokens will be burnt.
     * @param value The amount that will be burnt.
     */
    function _burn(address account, uint256 value) internal {
        require(account != address(0));

        _totalSupply = _totalSupply.sub(value);
        _balances[account] = _balances[account].sub(value);
        emit Transfer(account, address(0), value);
    }

    /**
     * @dev Approve an address to spend another addresses' tokens.
     * @param owner The address that owns the tokens.
     * @param spender The address that will spend the tokens.
     * @param value The number of tokens that can be spent.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        require(spender != address(0));
        require(owner != address(0));

        _allowed[owner][spender] = value;
        emit Approval(owner, spender, value);
    }

    /**
     * @dev Internal function that burns an amount of the token of a given
     * account, deducting from the sender's allowance for said account. Uses the
     * internal burn function.
     * Emits an Approval event (reflecting the reduced allowance).
     * @param account The account whose tokens will be burnt.
     * @param value The amount that will be burnt.
     */
    function _burnFrom(address account, uint256 value) internal {
        _burn(account, value);
        _approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
    }
}

// File: contracts/common/tokens/ERC20NonTransferable.sol

pragma solidity ^0.5.2;


contract ERC20NonTransferable is ERC20 {
    function _transfer(
        address from,
        address to,
        uint256 value
    ) internal {
        revert("Disabled");
    }
}

// File: contracts/common/mixin/OwnableLockable.sol

pragma solidity ^0.5.2;



contract OwnableLockable is Lockable, Ownable {
    function lock() public onlyOwner {
        super.lock();
    }

    function unlock() public onlyOwner {
        super.unlock();
    }
}

// File: contracts/common/mixin/Initializable.sol

pragma solidity ^0.5.2;

contract Initializable {
    bool inited = false;

    modifier initializer() {
        require(!inited, "already inited");
        inited = true;
        
        _;
    }
}

// File: contracts/staking/validatorShare/ValidatorShare.sol

pragma solidity ^0.5.2;








contract ValidatorShare is IValidatorShare, ERC20NonTransferable, OwnableLockable, Initializable {
    struct Delegator {
        uint256 shares;
        uint256 withdrawEpoch;
    }

    uint256 constant EXCHANGE_RATE_PRECISION = 100;
    uint256 constant MAX_COMMISION_RATE = 100;
    uint256 constant REWARD_PRECISION = 10**25;

    StakingInfo public stakingLogger;
    IStakeManager public stakeManager;
    uint256 public validatorId;
    uint256 public validatorRewards;
    uint256 public commissionRate;
    //last checkpoint where validator updated commission rate
    uint256 public lastCommissionUpdate;
    uint256 public minAmount = 10**18;

    uint256 public totalStake;
    uint256 public rewardPerShare;
    uint256 public activeAmount;
    bool public delegation = true;

    uint256 public withdrawPool;
    uint256 public withdrawShares;

    mapping(address => uint256) public amountStaked;
    mapping(address => Delegator) public delegators;
    mapping(address => uint256) public initalRewardPerShare;

    modifier onlyValidator() {
        require(stakeManager.ownerOf(validatorId) == msg.sender, "not validator");
        _;
    }

    // onlyOwner will prevent this contract from initializing, since it's owner is going to be 0x0 address
    function initialize(uint256 _validatorId, address _stakingLogger, address _stakeManager) external initializer  {
        validatorId = _validatorId;
        stakingLogger = StakingInfo(_stakingLogger);
        stakeManager = IStakeManager(_stakeManager);
        _transferOwnership(_stakeManager);

        minAmount = 10**18;
        delegation = true;
    }

    function updateCommissionRate(uint256 newCommissionRate) external onlyValidator {
        uint256 epoch = stakeManager.epoch();
        uint256 _lastCommissionUpdate = lastCommissionUpdate;

        require( // withdrawalDelay == dynasty
            (_lastCommissionUpdate.add(stakeManager.withdrawalDelay()) <= epoch) || _lastCommissionUpdate == 0, // For initial setting of commission rate
            "Commission rate update cooldown period"
        );

        require(newCommissionRate <= MAX_COMMISION_RATE, "Commission rate should be in range of 0-100");
        stakingLogger.logUpdateCommissionRate(validatorId, newCommissionRate, commissionRate);
        commissionRate = newCommissionRate;
        lastCommissionUpdate = epoch;
    }

    function updateRewards(uint256 reward, uint256 checkpointStakePower, uint256 validatorStake)
        external
        onlyOwner
        returns (uint256)
    {
        /**
        restaking is simply buying more shares of pool
        but those needs to be nonswapable/transferrable(to prevent https://en.wikipedia.org/wiki/Tragedy_of_the_commons)

        - calculate rewards for validator stake + delgation
        - keep the validator rewards aside
        - take the commission out
        - add rewards to pool rewards
        - returns total active stake for validator
        */
        uint256 combinedStakePower = validatorStake.add(activeAmount); // validator + delegation stake power
        uint256 rewards = combinedStakePower.mul(reward).div(checkpointStakePower);

        _updateRewards(rewards, validatorStake, combinedStakePower);
        return combinedStakePower;
    }

    function addProposerBonus(uint256 rewards, uint256 validatorStake) public onlyOwner {
        uint256 combinedStakePower = validatorStake.add(activeAmount);
        _updateRewards(rewards, validatorStake, combinedStakePower);
    }

    function _updateRewards(uint256 rewards, uint256 validatorStake, uint256 combinedStakePower) internal {
        uint256 _validatorRewards = validatorStake.mul(rewards).div(combinedStakePower);

        // add validator commission from delegation rewards
        if (commissionRate > 0) {
            _validatorRewards = _validatorRewards.add(
                rewards.sub(_validatorRewards).mul(commissionRate).div(MAX_COMMISION_RATE)
            );
        }

        validatorRewards = validatorRewards.add(_validatorRewards);

        uint256 delegatorsRewards = rewards.sub(_validatorRewards);
        uint256 totalShares = totalSupply();
        if (totalShares > 0) {
            rewardPerShare = rewardPerShare.add(
                delegatorsRewards.mul(REWARD_PRECISION).div(totalShares)
            );
        }
    }

    function withdrawRewardsValidator() external onlyOwner returns (uint256) {
        uint256 _validatorRewards = validatorRewards;
        validatorRewards = 0;
        return _validatorRewards;
    }

    function exchangeRate() public view returns (uint256) {
        uint256 totalShares = totalSupply();
        return
            totalShares == 0
                ? EXCHANGE_RATE_PRECISION
                : activeAmount.mul(EXCHANGE_RATE_PRECISION).div(totalShares);
    }

    function withdrawExchangeRate() public view returns (uint256) {
        uint256 _withdrawShares = withdrawShares;
        return
            _withdrawShares == 0
                ? EXCHANGE_RATE_PRECISION
                : withdrawPool.mul(EXCHANGE_RATE_PRECISION).div(_withdrawShares);
    }

    function buyVoucher(uint256 _amount, uint256 _minSharesToMint) public {
        _withdrawAndTransferReward();
        uint256 amountToDeposit = _buyShares(_amount, _minSharesToMint);
        require(stakeManager.delegationDeposit(validatorId, amountToDeposit, msg.sender), "deposit failed");
    }

    function restake() public {
        uint256 liquidReward = _withdrawReward(msg.sender);
        require(liquidReward >= minAmount, "Too small rewards to restake");

        _buyShares(liquidReward, 0);

        stakingLogger.logDelegatorRestaked(validatorId, msg.sender, amountStaked[msg.sender]);
    }

    function _buyShares(uint256 _amount, uint256 _minSharesToMint) private onlyWhenUnlocked returns(uint256) {
        require(delegation, "Delegation is disabled");

        uint256 rate = exchangeRate();
        uint256 shares = _amount.mul(EXCHANGE_RATE_PRECISION).div(rate);
        require(shares >= _minSharesToMint, "Too much slippage");
        require(delegators[msg.sender].shares == 0, "Ongoing exit");

        _mint(msg.sender, shares);

        _amount = _amount.sub(_amount % rate.mul(shares).div(EXCHANGE_RATE_PRECISION));

        totalStake = totalStake.add(_amount);
        amountStaked[msg.sender] = amountStaked[msg.sender].add(_amount);

        activeAmount = activeAmount.add(_amount);
        stakeManager.updateValidatorState(validatorId, int256(_amount));

        StakingInfo logger = stakingLogger;
        logger.logShareMinted(validatorId, msg.sender, _amount, shares);
        logger.logStakeUpdate(validatorId);

        return _amount;
    }

    function sellVoucher(uint256 _minClaimAmount) public {
        uint256 shares = balanceOf(msg.sender);
        require(shares > 0, "Zero balance");

        uint256 rate = exchangeRate();
        uint256 _amount = rate.mul(shares).div(EXCHANGE_RATE_PRECISION);
        require(_amount >= _minClaimAmount, "Too much slippage");

        _withdrawAndTransferReward();
        _burn(msg.sender, shares);
        stakeManager.updateValidatorState(validatorId, -int256(_amount));

        activeAmount = activeAmount.sub(_amount);
        uint256 _withdrawPoolShare = _amount.mul(EXCHANGE_RATE_PRECISION).div(withdrawExchangeRate());

        withdrawPool = withdrawPool.add(_amount);
        withdrawShares = withdrawShares.add(_withdrawPoolShare);
        delegators[msg.sender] = Delegator({shares: _withdrawPoolShare, withdrawEpoch: stakeManager.epoch()});
        amountStaked[msg.sender] = 0;

        StakingInfo logger = stakingLogger;
        logger.logShareBurned(validatorId, msg.sender, _amount, shares);
        logger.logStakeUpdate(validatorId);
    }

    function _withdrawReward(address user) private returns(uint256) {
        uint256 liquidRewards = getLiquidRewards(user);
        initalRewardPerShare[user] = rewardPerShare;
        return liquidRewards;
    }

    function _withdrawAndTransferReward() private returns(uint256) {
        uint256 liquidRewards = _withdrawReward(msg.sender);
        if (liquidRewards > 0) {
            require(stakeManager.transferFunds(validatorId, liquidRewards, msg.sender), "Insufficent rewards");
            stakingLogger.logDelegatorClaimRewards(validatorId, msg.sender, liquidRewards);
        }
        return liquidRewards;
    }

    function withdrawRewards() public {
        uint256 rewards = _withdrawAndTransferReward();
        require(rewards >= minAmount, "Too small rewards amount");
    }

    function getLiquidRewards(address user) public view returns (uint256) {
        uint256 shares = balanceOf(user);
        if (shares == 0) {
            return 0;
        }

        return rewardPerShare.sub(initalRewardPerShare[user]).mul(shares).div(REWARD_PRECISION);
    }

    function unstakeClaimTokens() public {
        Delegator storage delegator = delegators[msg.sender];

        uint256 shares = delegator.shares;
        require(
            delegator.withdrawEpoch.add(stakeManager.withdrawalDelay()) <= stakeManager.epoch() && shares > 0,
            "Incomplete withdrawal period"
        );

        uint256 _amount = withdrawExchangeRate().mul(shares).div(EXCHANGE_RATE_PRECISION);
        withdrawShares = withdrawShares.sub(shares);
        withdrawPool = withdrawPool.sub(_amount);

        totalStake = totalStake.sub(_amount);

        require(stakeManager.transferFunds(validatorId, _amount, msg.sender), "Insufficent rewards");
        stakingLogger.logDelegatorUnstaked(validatorId, msg.sender, _amount);
        delete delegators[msg.sender];
    }

    function slash(uint256 valPow, uint256 totalAmountToSlash) external onlyOwner returns (uint256) {
        uint256 _withdrawPool = withdrawPool;
        uint256 delegationAmount = activeAmount.add(_withdrawPool);
        if (delegationAmount == 0) {
            return 0;
        }
        // total amount to be slashed from delegation pool (active + inactive)
        uint256 _amountToSlash = delegationAmount.mul(totalAmountToSlash).div(valPow.add(delegationAmount));
        uint256 _amountToSlashWithdrawalPool = _withdrawPool.mul(_amountToSlash).div(delegationAmount);

        // slash inactive pool
        withdrawPool = _withdrawPool.sub(_amountToSlashWithdrawalPool);
        activeAmount = activeAmount.sub(_amountToSlash.sub(_amountToSlashWithdrawalPool));
        return _amountToSlash;
    }

    function updateDelegation(bool _delegation) external onlyOwner {
        delegation = _delegation;
    }

    function drain(
        address token,
        address payable destination,
        uint256 amount
    ) external onlyOwner {
        if (token == address(0x0)) {
            destination.transfer(amount);
        } else {
            require(ERC20(token).transfer(destination, amount), "Drain failed");
        }
    }

    function getActiveAmount() external view returns(uint256) {
        return activeAmount;
    }

    function unlockContract() external onlyOwner returns (uint256) {
        unlock();
        return activeAmount;
    }

    function lockContract() external onlyOwner returns (uint256) {
        lock();
        return activeAmount;
    }
}

// File: contracts/staking/validatorShare/ValidatorShareFactory.sol

pragma solidity ^0.5.2;



contract ValidatorShareFactory {
    /**
    - factory to create new validatorShare contracts
   */
    function create(uint256 validatorId, address loggerAddress, address registry) public returns (address) {
        ValidatorShareProxy proxy = new ValidatorShareProxy(registry);

        proxy.transferOwnership(msg.sender);

        address proxyAddr = address(proxy);
        (bool success, bytes memory data) = proxyAddr.call.gas(gasleft())(
            abi.encodeWithSelector(
                ValidatorShare(proxyAddr).initialize.selector, 
                validatorId, 
                loggerAddress, 
                msg.sender
            )
        );
        require(success, string(data));

        return proxyAddr;
    }
}

// File: contracts/staking/slashing/ISlashingManager.sol

pragma solidity ^0.5.2;




contract ISlashingManager {
    bytes32 public heimdallId;
    uint8 public constant VOTE_TYPE = 2;
    uint256 public reportRate = 5; // dummy default value
    uint256 public proposerRate = 50; // dummy default value
    uint256 public jailCheckpoints = 5; // checkpoints
    uint256 public slashingNonce;
    Registry public registry;
    StakingInfo public logger;
}

// File: contracts/staking/stakeManager/StakeManagerStorage.sol

pragma solidity ^0.5.2;









contract StakeManagerStorage is GovernanceLockable, RootChainable {
    IERC20 public token;
    address public registry;
    StakingInfo public logger;
    StakingNFT public NFTContract;
    ValidatorShareFactory public factory;
    uint256 public WITHDRAWAL_DELAY; // unit: epoch
    uint256 public currentEpoch;

    // genesis/governance variables
    uint256 public dynasty ; // unit: epoch 50 days
    uint256 public CHECKPOINT_REWARD; // update via governance
    uint256 public minDeposit; // in ERC20 token
    uint256 public minHeimdallFee; // in ERC20 token
    uint256 public checkPointBlockInterval;
    uint256 public signerUpdateLimit;

    uint256 public validatorThreshold; //128
    uint256 public totalStaked;
    uint256 public NFTCounter;
    uint256 public totalRewards;
    uint256 public totalRewardsLiquidated;
    uint256 public auctionPeriod; // 1 week in epochs
    uint256 public proposerBonus; // 10 % of total rewards
    bytes32 public accountStateRoot;
    // Stop validator auction for some time when updating dynasty value
    uint256 public replacementCoolDown;
    bool public delegationEnabled;

    struct Auction {
        uint256 amount;
        uint256 startEpoch;
        address user;
        bool acceptDelegation;
        bytes signerPubkey;
    }

    struct State {
        uint256 amount;
        uint256 stakerCount;
    }

    struct StateChange {
        int256 amount;
        int256 stakerCount;
    }

    enum Status {Inactive, Active, Locked, Unstaked}
    struct Validator {
        uint256 amount;
        uint256 reward;
        uint256 activationEpoch;
        uint256 deactivationEpoch;
        uint256 jailTime;
        address signer;
        address contractAddress;
        Status status;
    }

    mapping(uint256 => Validator) public validators;
    // signer to Validator mapping
    mapping(address => uint256) public signerToValidator;
    State public validatorState;
    mapping(uint256 => StateChange) public validatorStateChanges;

    mapping(address => uint256) public userFeeExit;
    //Ongoing auctions for validatorId
    mapping(uint256 => Auction) public validatorAuction;
    // validatorId to last signer update epoch
    mapping(uint256 => uint256) public latestSignerUpdateEpoch;

    uint256 public totalHeimdallFee;
}

// File: contracts/staking/stakeManager/StakeManager.sol

pragma solidity ^0.5.2;






















contract StakeManager is IStakeManager, StakeManagerStorage, Initializable {
    using SafeMath for uint256;
    using ECVerify for bytes32;
    using Merkle for bytes32;
    using RLPReader for bytes;
    using RLPReader for RLPReader.RLPItem;

    uint256 private constant INCORRECT_VALIDATOR_ID = 2**256 - 1;

    modifier onlyStaker(uint256 validatorId) {
        _assertOnlyStaker(validatorId);
        _;
    }

    function _assertOnlyStaker(uint256 validatorId) private view {
        require(NFTContract.ownerOf(validatorId) == msg.sender);
    }

    constructor() public GovernanceLockable(address(0x0)) {}

    function initialize(
        address _registry,
        address _rootchain,
        address _token,
        address _NFTContract,
        address _stakingLogger,
        address _validatorShareFactory,
        address _governance,
        address _owner
    ) external initializer {
        governance = IGovernance(_governance);
        registry = _registry;
        rootChain = _rootchain;
        token = IERC20(_token);
        NFTContract = StakingNFT(_NFTContract);
        logger = StakingInfo(_stakingLogger);
        factory = ValidatorShareFactory(_validatorShareFactory);
        _transferOwnership(_owner);

        WITHDRAWAL_DELAY = (2**13); // unit: epoch
        currentEpoch = 1;
        dynasty = 886; // unit: epoch 50 days
        CHECKPOINT_REWARD = 20188 * (10**18); // update via governance
        minDeposit = (10**18); // in ERC20 token
        minHeimdallFee = (10**18); // in ERC20 token
        checkPointBlockInterval = 1024;
        signerUpdateLimit = 100;

        validatorThreshold = 7; //128
        NFTCounter = 1;
        auctionPeriod = (2**13) / 4; // 1 week in epochs
        proposerBonus = 10; // 10 % of total rewards
        delegationEnabled = true;
    }

    function setDelegationEnabled(bool enabled) public onlyGovernance {
        delegationEnabled = enabled;
    }

    // TopUp heimdall fee
    function topUpForFee(address user, uint256 heimdallFee) public onlyWhenUnlocked {
        _transferAndTopUp(user, heimdallFee, 0);
    }

    function ownerOf(uint256 tokenId) public view returns (address) {
        return NFTContract.ownerOf(tokenId);
    }

    function epoch() public view returns (uint256) {
        return currentEpoch;
    }

    function withdrawalDelay() public view returns (uint256) {
        return WITHDRAWAL_DELAY;
    }

    function validatorStake(uint256 validatorId) public view returns (uint256) {
        return validators[validatorId].amount;
    }

    function _transferAndTopUp(
        address user,
        uint256 fee,
        uint256 additionalAmount
    ) private {
        require(fee >= minHeimdallFee, "Not enough heimdall fee");
        require(token.transferFrom(msg.sender, address(this), fee.add(additionalAmount)), "Fee transfer failed");
        totalHeimdallFee = totalHeimdallFee.add(fee);
        logger.logTopUpFee(user, fee);
    }

    function _claimFee(address user, uint256 amount) private {
        totalHeimdallFee = totalHeimdallFee.sub(amount);
        logger.logClaimFee(user, amount);
    }

    function claimFee(
        uint256 accumFeeAmount,
        uint256 index,
        bytes memory proof
    ) public {
        //Ignoring other params becuase rewards distribution is on chain
        require(
            keccak256(abi.encode(msg.sender, accumFeeAmount)).checkMembership(index, accountStateRoot, proof),
            "Wrong acc proof"
        );
        uint256 withdrawAmount = accumFeeAmount.sub(userFeeExit[msg.sender]);
        _claimFee(msg.sender, withdrawAmount);
        userFeeExit[msg.sender] = accumFeeAmount;
        require(token.transfer(msg.sender, withdrawAmount));
    }

    function stake(
        uint256 amount,
        uint256 heimdallFee,
        bool acceptDelegation,
        bytes calldata signerPubkey
    ) external {
        stakeFor(msg.sender, amount, heimdallFee, acceptDelegation, signerPubkey);
    }

    function totalStakedFor(address user) external view returns (uint256) {
        if (user == address(0x0) || NFTContract.balanceOf(user) == 0) {
            return 0;
        }
        return validators[NFTContract.tokenOfOwnerByIndex(user, 0)].amount;
    }

    function startAuction(
        uint256 validatorId,
        uint256 amount,
        bool _acceptDelegation,
        bytes calldata _signerPubkey
    ) external onlyWhenUnlocked {
        uint256 currentValidatorAmount = validators[validatorId].amount;

        require(
            validators[validatorId].deactivationEpoch == 0 && currentValidatorAmount != 0,
            "Invalid validator for an auction"
        );
        uint256 senderValidatorId = signerToValidator[msg.sender];
        // make sure that signer wasn't used already
        require(
            NFTContract.balanceOf(msg.sender) == 0 && // existing validators can't bid
                senderValidatorId != INCORRECT_VALIDATOR_ID,
            "Already used address"
        );

        uint256 _currentEpoch = currentEpoch;
        uint256 _replacementCoolDown = replacementCoolDown;
        // when dynasty period is updated validators are in cooldown period
        require(_replacementCoolDown == 0 || _replacementCoolDown <= _currentEpoch, "Cooldown period");
        // (auctionPeriod--dynasty)--(auctionPeriod--dynasty)--(auctionPeriod--dynasty)
        // if it's auctionPeriod then will get residue smaller then auctionPeriod
        // from (CurrentPeriod of validator )%(auctionPeriod--dynasty)
        // make sure that its `auctionPeriod` window
        // dynasty = 30, auctionPeriod = 7, activationEpoch = 1, currentEpoch = 39
        // residue 1 = (39-1)% (7+30), if residue <= auctionPeriod it's `auctionPeriod`

        require(
            (_currentEpoch.sub(validators[validatorId].activationEpoch) % dynasty.add(auctionPeriod)) < auctionPeriod,
            "Invalid auction period"
        );

        uint256 perceivedStake = currentValidatorAmount;
        address _contract = validators[validatorId].contractAddress;

        if (_contract != address(0x0)) {
            perceivedStake = perceivedStake.add(IValidatorShare(_contract).getActiveAmount());
        }

        Auction storage auction = validatorAuction[validatorId];
        uint256 currentAuctionAmount = auction.amount;

        perceivedStake = Math.max(perceivedStake, currentAuctionAmount);

        require(perceivedStake < amount, "Must bid higher");
        require(token.transferFrom(msg.sender, address(this), amount), "Transfer amount failed");

        //replace prev auction
        if (currentAuctionAmount != 0) {
            require(token.transfer(auction.user, currentAuctionAmount), "Bid return failed");
        }

        // create new auction
        auction.amount = amount;
        auction.user = msg.sender;
        auction.acceptDelegation = _acceptDelegation;
        auction.signerPubkey = _signerPubkey;

        logger.logStartAuction(validatorId, currentValidatorAmount, amount);
    }

    function confirmAuctionBid(
        uint256 validatorId,
        uint256 heimdallFee /** for new validator */
    ) external onlyWhenUnlocked {
        Auction storage auction = validatorAuction[validatorId];
        address auctionUser = auction.user;

        require(
            msg.sender == auctionUser || getValidatorId(msg.sender) == validatorId,
            "Only bidder or validator can confirm"
        );

        uint256 _currentEpoch = currentEpoch;
        require(
            _currentEpoch.sub(auction.startEpoch) % auctionPeriod.add(dynasty) >= auctionPeriod,
            "Not allowed before auctionPeriod"
        );
        require(auction.user != address(0x0), "Invalid auction");

        uint256 validatorAmount = validators[validatorId].amount;
        uint256 perceivedStake = validatorAmount;
        uint256 auctionAmount = auction.amount;
        address contractAddr = validators[validatorId].contractAddress;

        if (contractAddr != address(0x0)) {
            perceivedStake = perceivedStake.add(IValidatorShare(contractAddr).getActiveAmount());
        }

        // validator is last auctioner
        if (perceivedStake >= auctionAmount && validators[validatorId].deactivationEpoch == 0) {
            require(token.transfer(auctionUser, auctionAmount), "Bid return failed");
            //cleanup auction data
            auction.startEpoch = _currentEpoch;
            logger.logConfirmAuction(validatorId, validatorId, validatorAmount);
        } else {
            // dethrone
            _transferAndTopUp(auctionUser, heimdallFee, 0);
            _unstake(validatorId, _currentEpoch);

            uint256 newValidatorId = _stakeFor(
                auctionUser,
                auctionAmount,
                auction.acceptDelegation,
                auction.signerPubkey
            );
            logger.logConfirmAuction(newValidatorId, validatorId, auctionAmount);
        }
        uint256 startEpoch = auction.startEpoch;
        delete validatorAuction[validatorId];
        validatorAuction[validatorId].startEpoch = startEpoch;
    }

    function unstake(uint256 validatorId) external onlyStaker(validatorId) {
        require(validatorAuction[validatorId].amount == 0, "Wait for auction completion");
        require(
            validators[validatorId].activationEpoch > 0 &&
                validators[validatorId].deactivationEpoch == 0 &&
                (validators[validatorId].status == Status.Active || validators[validatorId].status == Status.Locked)
        );

        uint256 exitEpoch = currentEpoch.add(1); // notice period
        _unstake(validatorId, exitEpoch);
    }

    // Housekeeping function. @todo remove later
    function forceUnstake(uint256 validatorId) external onlyOwner {
        _unstake(validatorId, currentEpoch);
    }

    function setCurrentEpoch(uint256 _currentEpoch) external onlyOwner {
        currentEpoch = _currentEpoch;
    }

    function transferFunds(
        uint256 validatorId,
        uint256 amount,
        address delegator
    ) external returns (bool) {
        require(
            Registry(registry).getSlashingManagerAddress() == msg.sender ||
                validators[validatorId].contractAddress == msg.sender,
            "Invalid contract address"
        );
        return token.transfer(delegator, amount);
    }

    function delegationDeposit(
        uint256 validatorId,
        uint256 amount,
        address delegator
    ) external returns (bool) {
        require(delegationEnabled, "Delegation is disabled");
        require(validators[validatorId].contractAddress == msg.sender, "Invalid contract address");
        return token.transferFrom(delegator, address(this), amount);
    }

    function stakeFor(
        address user,
        uint256 amount,
        uint256 heimdallFee,
        bool acceptDelegation,
        bytes memory signerPubkey
    ) public onlyWhenUnlocked {
        require(currentValidatorSetSize() < validatorThreshold, "Validator set Threshold exceeded!");
        require(amount > minDeposit, "min deposit limit failed!");
        _transferAndTopUp(user, heimdallFee, amount);
        _stakeFor(user, amount, acceptDelegation, signerPubkey);
    }

    function unstakeClaim(uint256 validatorId) public onlyStaker(validatorId) {
        uint256 deactivationEpoch = validators[validatorId].deactivationEpoch;
        // can only claim stake back after WITHDRAWAL_DELAY
        require(
            deactivationEpoch > 0 &&
                deactivationEpoch.add(WITHDRAWAL_DELAY) <= currentEpoch &&
                validators[validatorId].status != Status.Unstaked
        );

        uint256 amount = validators[validatorId].amount;
        uint256 newTotalStaked = totalStaked.sub(amount);
        totalStaked = newTotalStaked;

        NFTContract.burn(validatorId);

        signerToValidator[validators[validatorId].signer] = INCORRECT_VALIDATOR_ID;
        validators[validatorId].status = Status.Unstaked;
        require(token.transfer(msg.sender, amount), "Transfer stake failed");
        logger.logUnstaked(msg.sender, validatorId, amount, newTotalStaked);
    }

    // slashing and jail interface
    function restake(
        uint256 validatorId,
        uint256 amount,
        bool stakeRewards
    ) public onlyWhenUnlocked onlyStaker(validatorId) {
        require(validators[validatorId].deactivationEpoch == 0, "No use of restaking");

        if (amount > 0) {
            require(token.transferFrom(msg.sender, address(this), amount), "Transfer stake failed");
        }

        if (stakeRewards) {
            amount = amount.add(validators[validatorId].reward);
            address contractAddr = validators[validatorId].contractAddress;
            if (contractAddr != address(0x0)) {
                amount = amount.add(IValidatorShare(contractAddr).withdrawRewardsValidator());
            }
            validators[validatorId].reward = 0;
        }

        uint256 newTotalStaked = totalStaked.add(amount);
        totalStaked = newTotalStaked;
        validators[validatorId].amount = validators[validatorId].amount.add(amount);

        updateTimeline(int256(amount), 0, 0);

        logger.logStakeUpdate(validatorId);
        logger.logRestaked(validatorId, validators[validatorId].amount, newTotalStaked);
    }

    function _liquidateRewards(uint256 validatorId, address validatorUser, uint256 reward) private {
        totalRewardsLiquidated = totalRewardsLiquidated.add(reward);
        validators[validatorId].reward = 0;
        require(token.transfer(validatorUser, reward), "Insufficent rewards");
        logger.logClaimRewards(validatorId, reward, totalRewardsLiquidated);
    }

    function withdrawRewards(uint256 validatorId) public onlyStaker(validatorId) {
        uint256 reward = validators[validatorId].reward;
        address contractAddr = validators[validatorId].contractAddress;
        if (contractAddr != address(0x0)) {
            reward = reward.add(IValidatorShare(contractAddr).withdrawRewardsValidator());
        }

        _liquidateRewards(validatorId, msg.sender, reward);
    }

    function getValidatorId(address user) public view returns (uint256) {
        return NFTContract.tokenOfOwnerByIndex(user, 0);
    }

    // set staking Token
    function setToken(address _token) public onlyOwner {
        require(_token != address(0x0));
        token = IERC20(_token);
    }

    // Change the number of validators required to allow a passed header root
    function updateValidatorThreshold(uint256 newThreshold) public onlyOwner {
        require(newThreshold > 0);
        logger.logThresholdChange(newThreshold, validatorThreshold);
        validatorThreshold = newThreshold;
    }

    function updateCheckPointBlockInterval(uint256 _blocks) public onlyOwner {
        require(_blocks > 0, "Blocks interval must be non-zero");
        checkPointBlockInterval = _blocks;
    }

    // Change reward for each checkpoint
    function updateCheckpointReward(uint256 newReward) public onlyOwner {
        require(newReward > 0);
        logger.logRewardUpdate(newReward, CHECKPOINT_REWARD);
        CHECKPOINT_REWARD = newReward;
    }

    // Change delegation contract for a validator
    // @note: Users must exit before this update or all funds may get lost
    function updateContractAddress(uint256 validatorId, address newContractAddress) public onlyOwner {
        require(IValidatorShare(newContractAddress).owner() == address(this), "Owner of contract must be stakeManager");
        validators[validatorId].contractAddress = newContractAddress;
    }

    function updateValidatorState(uint256 validatorId, int256 amount) public {
        require(validators[validatorId].contractAddress == msg.sender, "Invalid contract address");
        updateTimeline(amount, 0, 0);
    }

    function updateDynastyValue(uint256 newDynasty) public onlyOwner {
        require(newDynasty > 0);
        logger.logDynastyValueChange(newDynasty, dynasty);
        dynasty = newDynasty;
        WITHDRAWAL_DELAY = newDynasty;
        auctionPeriod = newDynasty.div(4);
        // set cooldown period
        replacementCoolDown = currentEpoch.add(auctionPeriod);
    }

    // Housekeeping function. @todo remove later
    function stopAuctions(uint256 forNCheckpoints) public onlyOwner {
        replacementCoolDown = currentEpoch.add(forNCheckpoints);
    }

    function updateProposerBonus(uint256 newProposerBonus) public onlyOwner {
        logger.logProposerBonusChange(newProposerBonus, proposerBonus);
        require(newProposerBonus <= 100, "too big");
        proposerBonus = newProposerBonus;
    }

    function updateSignerUpdateLimit(uint256 _limit) public onlyOwner {
        signerUpdateLimit = _limit;
    }

    function updateMinAmounts(uint256 _minDeposit, uint256 _minHeimdallFee) public onlyOwner {
        minDeposit = _minDeposit;
        minHeimdallFee = _minHeimdallFee;
    }

    function updateSigner(uint256 validatorId, bytes memory signerPubkey) public onlyStaker(validatorId) {
        address signer = pubToAddress(signerPubkey);
        require(signer != address(0x0) && signerToValidator[signer] == 0, "Invalid signer");

        uint256 _currentEpoch = currentEpoch;
        require(
            _currentEpoch >= latestSignerUpdateEpoch[validatorId].add(signerUpdateLimit),
            "Invalid checkpoint number!"
        );

        address currentSigner = validators[validatorId].signer;
        // update signer event
        logger.logSignerChange(validatorId, currentSigner, signer, signerPubkey);

        signerToValidator[currentSigner] = INCORRECT_VALIDATOR_ID;
        signerToValidator[signer] = validatorId;
        validators[validatorId].signer = signer;
        // reset update time to current time
        latestSignerUpdateEpoch[validatorId] = _currentEpoch;
    }

    function currentValidatorSetSize() public view returns (uint256) {
        return validatorState.stakerCount;
    }

    function currentValidatorSetTotalStake() public view returns (uint256) {
        return validatorState.amount;
    }

    function getValidatorContract(uint256 validatorId) public view returns (address) {
        return validators[validatorId].contractAddress;
    }

    function isValidator(uint256 validatorId) public view returns (bool) {
        uint256 activationEpoch = validators[validatorId].activationEpoch;
        uint256 deactivationEpoch = validators[validatorId].deactivationEpoch;
        uint256 amount = validators[validatorId].amount;
        Status status = validators[validatorId].status;
        uint256 _currentEpoch = currentEpoch;

        return (amount > 0 &&
            (activationEpoch != 0 && activationEpoch <= _currentEpoch) &&
            (deactivationEpoch == 0 || deactivationEpoch > _currentEpoch) &&
            status == Status.Active);
    }

    function checkSignatures(
        uint256 blockInterval,
        bytes32 voteHash,
        bytes32 stateRoot,
        address proposer,
        bytes memory sigs
    ) public onlyRootChain returns (uint256) {
        // checkpoint rewards are based on BlockInterval multiplied on `CHECKPOINT_REWARD`
        // for bigger checkpoints reward is capped at `CHECKPOINT_REWARD`
        // if interval is 50% of checkPointBlockInterval then reward R is half of `CHECKPOINT_REWARD`
        // and then stakePower is 90% of currentValidatorSetTotalStake then final reward is 90% of R
        uint256 reward = blockInterval.mul(CHECKPOINT_REWARD).div(checkPointBlockInterval);
        reward = Math.min(CHECKPOINT_REWARD, reward);

        uint256 _proposerBonus = reward.mul(proposerBonus).div(100);
        Validator storage _proposer = validators[signerToValidator[proposer]];
        if (_proposer.contractAddress != address(0x0)) {
            IValidatorShare(_proposer.contractAddress).addProposerBonus(_proposerBonus, _proposer.amount);
        } else {
            _proposer.reward = _proposer.reward.add(_proposerBonus);
        }

        reward = reward.sub(_proposerBonus);
        uint256 stakePower = currentValidatorSetTotalStake();
        // update stateMerkleTree root for accounts balance on heimdall chain
        accountStateRoot = stateRoot;
        _finalizeCommit();
        return checkSignature(stakePower, reward, voteHash, sigs);
    }

    function checkSignature(
        uint256 checkpointStakePower,
        uint256 reward,
        bytes32 voteHash,
        bytes memory sigs
    ) internal returns (uint256) {
        // total voting power
        uint256 totalStakePower;
        address lastAdd; // cannot have address(0x0) as an owner
        for (uint64 i = 0; i < sigs.length; i += 65) {
            address signer = voteHash.ecrecovery(BytesLib.slice(sigs, i, 65));
            uint256 validatorId = signerToValidator[signer];
            // check if signer is staker and not proposer
            if (signer == lastAdd) {
                break;
            } else if (isValidator(validatorId) && signer > lastAdd) {
                lastAdd = signer;

                Validator storage validator = validators[validatorId];
                uint256 valPow;
                // add delegation power
                address contractAddr = validator.contractAddress;
                if (contractAddr != address(0x0)) {
                    valPow = IValidatorShare(contractAddr).updateRewards(
                        reward,
                        checkpointStakePower,
                        validatorStake(validatorId)
                    );
                } else {
                    valPow = validator.amount;
                    validator.reward = validator.reward.add(valPow.mul(reward).div(checkpointStakePower));
                }
                totalStakePower = totalStakePower.add(valPow);
            }
        }

        reward = CHECKPOINT_REWARD.mul(totalStakePower).div(currentValidatorSetTotalStake());
        totalRewards = totalRewards.add(reward);
        require(totalStakePower >= currentValidatorSetTotalStake().mul(2).div(3).add(1), "2/3+1 non-majority!");

        return reward;
    }

    function slash(bytes memory _slashingInfoList) public returns (uint256) {
        require(Registry(registry).getSlashingManagerAddress() == msg.sender, "Sender must be slashing manager!");
        RLPReader.RLPItem[] memory slashingInfoList = _slashingInfoList.toRlpItem().toList();
        int256 valJailed = 0;
        uint256 jailedAmount = 0;
        uint256 totalAmount;
        for (uint256 i = 0; i < slashingInfoList.length; i++) {
            RLPReader.RLPItem[] memory slashData = slashingInfoList[i].toList();
            uint256 validatorId = slashData[0].toUint();
            uint256 _amount = slashData[1].toUint();
            totalAmount = totalAmount.add(_amount);

            if (validators[validatorId].contractAddress != address(0x0)) {
                uint256 delSlashedAmount = IValidatorShare(validators[validatorId].contractAddress).slash(
                    validators[validatorId].amount,
                    _amount
                );
                _amount = _amount.sub(delSlashedAmount);
            }

            validators[validatorId].amount = validators[validatorId].amount.sub(_amount);
            if (slashData[2].toBoolean()) {
                jailedAmount = jailedAmount.add(_jail(validatorId, 1));
                valJailed++;
            }
        }

        //update timeline
        updateTimeline(-int256(totalAmount.add(jailedAmount)), -valJailed, 0);

        return totalAmount;
    }

    function unjail(uint256 validatorId) public onlyStaker(validatorId) {
        require(validators[validatorId].status == Status.Locked, "Validator is not jailed");
        require(validators[validatorId].deactivationEpoch == 0, "Validator already unstaking");

        uint256 _currentEpoch = currentEpoch;
        require(validators[validatorId].jailTime <= _currentEpoch, "Incomplete jail period");

        uint256 amount = validators[validatorId].amount;
        require(amount >= minDeposit);

        uint256 delegationAmount = 0;
        if (validators[validatorId].contractAddress != address(0x0)) {
            delegationAmount = IValidatorShare(validators[validatorId].contractAddress).unlockContract();
        }

        // undo timline so that validator is normal validator
        updateTimeline(int256(amount.add(delegationAmount)), 1, 0);

        validators[validatorId].status = Status.Active;
        logger.logUnjailed(validatorId, validators[validatorId].signer);
    }

    function _jail(uint256 validatorId, uint256 jailCheckpoints) internal returns (uint256) {
        uint256 delegationAmount = 0;
        if (validators[validatorId].contractAddress != address(0x0)) {
            delegationAmount = IValidatorShare(validators[validatorId].contractAddress).lockContract();
        }

        uint256 _currentEpoch = currentEpoch;
        validators[validatorId].jailTime = _currentEpoch.add(jailCheckpoints);
        validators[validatorId].status = Status.Locked;
        logger.logJailed(validatorId, _currentEpoch, validators[validatorId].signer);
        return validators[validatorId].amount.add(delegationAmount);
    }

    function _stakeFor(
        address user,
        uint256 amount,
        bool acceptDelegation,
        bytes memory signerPubkey
    ) internal returns (uint256) {
        address signer = pubToAddress(signerPubkey);
        require(signer != address(0x0) && signerToValidator[signer] == 0, "Invalid signer");

        uint256 _currentEpoch = currentEpoch;
        uint256 validatorId = NFTCounter;
        StakingInfo _logger = logger;
        uint256 newTotalStaked = totalStaked.add(amount);
        totalStaked = newTotalStaked;

        validators[validatorId] = Validator({
            reward: 0,
            amount: amount,
            activationEpoch: _currentEpoch,
            deactivationEpoch: 0,
            jailTime: 0,
            signer: signer,
            contractAddress: acceptDelegation ? factory.create(validatorId, address(_logger), registry) : address(0x0),
            status: Status.Active
        });

        latestSignerUpdateEpoch[validatorId] = _currentEpoch;
        NFTContract.mint(user, validatorId);

        signerToValidator[signer] = validatorId;
        updateTimeline(int256(amount), 1, 0);
        // no Auctions for 1 dynasty
        validatorAuction[validatorId].startEpoch = _currentEpoch;
        _logger.logStaked(signer, signerPubkey, validatorId, _currentEpoch, amount, newTotalStaked);
        NFTCounter = validatorId.add(1);

        return validatorId;
    }

    function _unstake(uint256 validatorId, uint256 exitEpoch) internal {
        uint256 amount = validators[validatorId].amount;
        address validator = ownerOf(validatorId);

        validators[validatorId].deactivationEpoch = exitEpoch;

        // unbond all delegators in future
        int256 delegationAmount = 0;
        uint256 rewards = validators[validatorId].reward;
        address contractAddr = validators[validatorId].contractAddress;
        if (contractAddr != address(0x0)) {
            IValidatorShare validatorShare = IValidatorShare(contractAddr);
            rewards = rewards.add(validatorShare.withdrawRewardsValidator());
            delegationAmount = int256(validatorShare.lockContract());
        }

        _liquidateRewards(validatorId, validator, rewards);

        //  update future
        updateTimeline(-(int256(amount) + delegationAmount), -1, exitEpoch);

        logger.logUnstakeInit(validator, validatorId, exitEpoch, amount);
    }

    function _finalizeCommit() internal {
        uint256 _currentEpoch = currentEpoch;
        uint256 nextEpoch = _currentEpoch.add(1);

        StateChange memory changes = validatorStateChanges[nextEpoch];
        updateTimeline(changes.amount, changes.stakerCount, 0);

        delete validatorStateChanges[_currentEpoch];

        currentEpoch = nextEpoch;
    }

    function updateTimeline(
        int256 amount,
        int256 stakerCount,
        uint256 targetEpoch
    ) private {
        if (targetEpoch == 0) {
            // update totalstake and validator count
            if (amount > 0) {
                validatorState.amount = validatorState.amount.add(uint256(amount));
            } else if (amount < 0) {
                validatorState.amount = validatorState.amount.sub(uint256(amount * -1));
            }

            if (stakerCount > 0) {
                validatorState.stakerCount = validatorState.stakerCount.add(uint256(stakerCount));
            } else if (stakerCount < 0) {
                validatorState.stakerCount = validatorState.stakerCount.sub(uint256(stakerCount * -1));
            }
        } else {
            validatorStateChanges[targetEpoch].amount += amount;
            validatorStateChanges[targetEpoch].stakerCount += stakerCount;
        }
    }

    function pubToAddress(bytes memory pub) private pure returns (address) {
        require(pub.length == 64, "Invalid pubkey");
        return address(uint160(uint256(keccak256(pub))));
    }

    function drainValidatorShares(
        uint256 validatorId,
        address _token,
        address payable destination,
        uint256 amount
    ) external onlyGovernance {
        address contractAddr = validators[validatorId].contractAddress;
        require(contractAddr != address(0x0), "unknown validator or no delegation enabled");
        IValidatorShare validatorShare = IValidatorShare(contractAddr);
        validatorShare.drain(_token, destination, amount);
    }

    function drain(address destination, uint256 amount) external onlyGovernance {
        require(token.transfer(destination, amount), "Drain failed");
    }

    function reinitialize(
        address _NFTContract,
        address _stakingLogger,
        address _validatorShareFactory
    ) external onlyGovernance {
        NFTContract = StakingNFT(_NFTContract);
        logger = StakingInfo(_stakingLogger);
        factory = ValidatorShareFactory(_validatorShareFactory);
    }

    function updateValidatorDelegation(bool delegation) external {
        uint256 validatorId = signerToValidator[msg.sender];
        require(isValidator(validatorId), "not a validator");

        address contractAddr = validators[validatorId].contractAddress;
        require(contractAddr != address(0x0), "delegation not enabled");

        IValidatorShare(contractAddr).updateDelegation(delegation);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousRootChain","type":"address"},{"indexed":true,"internalType":"address","name":"newRootChain","type":"address"}],"name":"RootChainChanged","type":"event"},{"constant":true,"inputs":[],"name":"CHECKPOINT_REWARD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"NFTContract","outputs":[{"internalType":"contract StakingNFT","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"NFTCounter","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"WITHDRAWAL_DELAY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"accountStateRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"auctionPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newRootChain","type":"address"}],"name":"changeRootChain","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"checkPointBlockInterval","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"blockInterval","type":"uint256"},{"internalType":"bytes32","name":"voteHash","type":"bytes32"},{"internalType":"bytes32","name":"stateRoot","type":"bytes32"},{"internalType":"address","name":"proposer","type":"address"},{"internalType":"bytes","name":"sigs","type":"bytes"}],"name":"checkSignatures","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"accumFeeAmount","type":"uint256"},{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"bytes","name":"proof","type":"bytes"}],"name":"claimFee","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"validatorId","type":"uint256"},{"internalType":"uint256","name":"heimdallFee","type":"uint256"}],"name":"confirmAuctionBid","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"currentEpoch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"currentValidatorSetSize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"currentValidatorSetTotalStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"validatorId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"delegator","type":"address"}],"name":"delegationDeposit","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"delegationEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"destination","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"drain","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"validatorId","type":"uint256"},{"internalType":"address","name":"_token","type":"address"},{"internalType":"address payable","name":"destination","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"drainValidatorShares","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"dynasty","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"epoch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"factory","outputs":[{"internalType":"contract ValidatorShareFactory","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"validatorId","type":"uint256"}],"name":"forceUnstake","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"validatorId","type":"uint256"}],"name":"getValidatorContract","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getValidatorId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"governance","outputs":[{"internalType":"contract IGovernance","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_registry","type":"address"},{"internalType":"address","name":"_rootchain","type":"address"},{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_NFTContract","type":"address"},{"internalType":"address","name":"_stakingLogger","type":"address"},{"internalType":"address","name":"_validatorShareFactory","type":"address"},{"internalType":"address","name":"_governance","type":"address"},{"internalType":"address","name":"_owner","type":"address"}],"name":"initialize","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"validatorId","type":"uint256"}],"name":"isValidator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"latestSignerUpdateEpoch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"lock","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"locked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"logger","outputs":[{"internalType":"contract StakingInfo","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"minDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"minHeimdallFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"proposerBonus","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"registry","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_NFTContract","type":"address"},{"internalType":"address","name":"_stakingLogger","type":"address"},{"internalType":"address","name":"_validatorShareFactory","type":"address"}],"name":"reinitialize","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"replacementCoolDown","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"validatorId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"stakeRewards","type":"bool"}],"name":"restake","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"rootChain","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_currentEpoch","type":"uint256"}],"name":"setCurrentEpoch","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bool","name":"enabled","type":"bool"}],"name":"setDelegationEnabled","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"setToken","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"signerToValidator","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"signerUpdateLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"bytes","name":"_slashingInfoList","type":"bytes"}],"name":"slash","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"heimdallFee","type":"uint256"},{"internalType":"bool","name":"acceptDelegation","type":"bool"},{"internalType":"bytes","name":"signerPubkey","type":"bytes"}],"name":"stake","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"heimdallFee","type":"uint256"},{"internalType":"bool","name":"acceptDelegation","type":"bool"},{"internalType":"bytes","name":"signerPubkey","type":"bytes"}],"name":"stakeFor","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"validatorId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"_acceptDelegation","type":"bool"},{"internalType":"bytes","name":"_signerPubkey","type":"bytes"}],"name":"startAuction","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"forNCheckpoints","type":"uint256"}],"name":"stopAuctions","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"heimdallFee","type":"uint256"}],"name":"topUpForFee","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalHeimdallFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalRewardsLiquidated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"totalStakedFor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"validatorId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"delegator","type":"address"}],"name":"transferFunds","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"validatorId","type":"uint256"}],"name":"unjail","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"unlock","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"validatorId","type":"uint256"}],"name":"unstake","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"validatorId","type":"uint256"}],"name":"unstakeClaim","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_blocks","type":"uint256"}],"name":"updateCheckPointBlockInterval","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"newReward","type":"uint256"}],"name":"updateCheckpointReward","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"validatorId","type":"uint256"},{"internalType":"address","name":"newContractAddress","type":"address"}],"name":"updateContractAddress","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"newDynasty","type":"uint256"}],"name":"updateDynastyValue","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_minDeposit","type":"uint256"},{"internalType":"uint256","name":"_minHeimdallFee","type":"uint256"}],"name":"updateMinAmounts","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"newProposerBonus","type":"uint256"}],"name":"updateProposerBonus","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"validatorId","type":"uint256"},{"internalType":"bytes","name":"signerPubkey","type":"bytes"}],"name":"updateSigner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_limit","type":"uint256"}],"name":"updateSignerUpdateLimit","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bool","name":"delegation","type":"bool"}],"name":"updateValidatorDelegation","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"validatorId","type":"uint256"},{"internalType":"int256","name":"amount","type":"int256"}],"name":"updateValidatorState","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"newThreshold","type":"uint256"}],"name":"updateValidatorThreshold","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userFeeExit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"validatorAuction","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"startEpoch","type":"uint256"},{"internalType":"address","name":"user","type":"address"},{"internalType":"bool","name":"acceptDelegation","type":"bool"},{"internalType":"bytes","name":"signerPubkey","type":"bytes"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"validatorId","type":"uint256"}],"name":"validatorStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"validatorState","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"stakerCount","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"validatorStateChanges","outputs":[{"internalType":"int256","name":"amount","type":"int256"},{"internalType":"int256","name":"stakerCount","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"validatorThreshold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"validators","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"reward","type":"uint256"},{"internalType":"uint256","name":"activationEpoch","type":"uint256"},{"internalType":"uint256","name":"deactivationEpoch","type":"uint256"},{"internalType":"uint256","name":"jailTime","type":"uint256"},{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"contractAddress","type":"address"},{"internalType":"enum StakeManagerStorage.Status","name":"status","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"validatorId","type":"uint256"}],"name":"withdrawRewards","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"withdrawalDelay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]

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

ECVerify : 0x71d91a8988d81617be53427126ee62471321b7df
Merkle : 0x8b90c7633f1f751e19e76433990b1663c625b258

115649:31280:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;115649:31280:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;119503:248;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;119503:248:0;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;119503:248:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;119503:248:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;-1:-1;119503:248:0;;-1:-1:-1;119503:248:0;-1:-1:-1;119503:248:0;:::i;:::-;;135033:1483;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;135033:1483:0;;;;;;;;;;;;;-1:-1:-1;;;;;135033:1483:0;;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;135033:1483:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;135033:1483:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;135033:1483:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;135033:1483:0;;-1:-1:-1;135033:1483:0;;-1:-1:-1;;;;;135033:1483:0:i;:::-;;;;;;;;;;;;;;;;132760:111;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;132760:111:0;;:::i;114000:28::-;;;:::i;113922:27::-;;;:::i;113378:31::-;;;:::i;130336:134::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;130336:134:0;-1:-1:-1;;;;;130336:134:0;;:::i;130557:231::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;130557:231:0;;:::i;130168:134::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;130168:134:0;-1:-1:-1;;;;;130168:134:0;;:::i;139827:1009::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;139827:1009:0;;:::i;114115:31::-;;;:::i;125761:114::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;125761:114:0;;:::i;113725:38::-;;;:::i;115146:60::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;115146:60:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;134405:620;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;134405:620:0;;:::i;:::-;;;;;;;;;;;;;;;;;;128181:1160;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;128181:1160:0;;;;;;;;;;;;;;:::i;125021:558::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;125021:558:0;;:::i;113299:29::-;;;:::i;:::-;;;;-1:-1:-1;;;;;113299:29:0;;;;;;;;;;;;;;114055:28;;;:::i;114963:47::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;114963:47:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;114963:47:0;-1:-1:-1;;;;;114963:47:0;;;;;;-1:-1:-1;;;;;114963:47:0;-1:-1:-1;;;;;114963:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;115053:52;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;115053:52:0;-1:-1:-1;;;;;115053:52:0;;:::i;113621:25::-;;;:::i;145518:487::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;145518:487:0;;;-1:-1:-1;;;;;145518:487:0;;;;;;;;;;;;;;;;;;;:::i;119759:262::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;119759:262:0;-1:-1:-1;;;;;119759:262:0;;:::i;113770:32::-;;;:::i;113811:33::-;;;:::i;126697:495::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;126697:495:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;126697:495:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;126697:495:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;126697:495:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;126697:495:0;;-1:-1:-1;126697:495:0;;-1:-1:-1;;;;;126697:495:0:i;115308:51::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;115308:51:0;;:::i;:::-;;;;;;;;;;;;;;;-1:-1:-1;;;;;115308:51:0;-1:-1:-1;;;;;115308:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;115308:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;114267:29;;;:::i;113890:25::-;;;:::i;134251:146::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;134251:146:0;;:::i;26600:29::-;;;:::i;138352:1467::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;138352:1467:0;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;138352:1467:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;138352:1467:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;138352:1467:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;138352:1467:0;;-1:-1:-1;138352:1467:0;;-1:-1:-1;;;;;138352:1467:0:i;117827:118::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;117827:118:0;;:::i;117681:138::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;117681:138:0;;;;;;;;:::i;146176:328::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;146176:328:0;;;;;;;;;;;;;;;;;;;:::i;118882:613::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;118882:613:0;;;;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;118882:613:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;118882:613:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;118882:613:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;118882:613:0;;-1:-1:-1;118882:613:0;;-1:-1:-1;;;;;118882:613:0:i;126306:383::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;126306:383:0;;;;;;;;;;;-1:-1:-1;;;;;126306:383:0;;:::i;113504:22::-;;;:::i;5306:140::-;;;:::i;113431:27::-;;;:::i;114226:34::-;;;:::i;115215:46::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;115215:46:0;-1:-1:-1;;;;;115215:46:0;;:::i;113237:23::-;;;:::i;113557:32::-;;;:::i;134000:117::-;;;:::i;113857:26::-;;;:::i;116292:1234::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;116292:1234:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;4516:79::-;;;:::i;4851:92::-;;;:::i;117953:85::-;;;:::i;125637:116::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;125637:116:0;;:::i;129733:427::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;129733:427:0;;:::i;27894:24::-;;;:::i;122875:2138::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;122875:2138:0;;;;;;;:::i;115481:31::-;;;:::i;132502:250::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;132502:250:0;;:::i;131691:221::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;131691:221:0;;;;;;;:::i;130796:192::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;130796:192:0;;:::i;134125:118::-;;;:::i;120029:2838::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;120029:2838:0;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;120029:2838:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;120029:2838:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;-1:-1;120029:2838:0;;-1:-1:-1;120029:2838:0;-1:-1:-1;120029:2838:0;:::i;27656:73::-;;;:::i;118046:99::-;;;:::i;146013:155::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;146013:155:0;;;;;;;;:::i;132879:175::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;132879:175:0;;;;;;;:::i;125883:415::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;125883:415:0;;;;;;;;;;;-1:-1:-1;;;;;125883:415:0;;:::i;113335:36::-;;;:::i;131038:212::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;131038:212:0;;:::i;113956:37::-;;;:::i;27027:18::-;;;:::i;146512:414::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;146512:414:0;;;;:::i;115414:58::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;115414:58:0;;:::i;127200:937::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;127200:937:0;;:::i;115112:27::-;;;:::i;131920:378::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;131920:378:0;;:::i;28374:210::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;28374:210:0;-1:-1:-1;;;;;28374:210:0;;:::i;118153:131::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;118153:131:0;;:::i;113267:25::-;;;:::i;117534:112::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;117534:112:0;;;;:::i;5623:109::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;5623:109:0;-1:-1:-1;;;;;5623:109:0;;:::i;133062:930::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;133062:930:0;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;133062:930:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;133062:930:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;133062:930:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;133062:930:0;;-1:-1:-1;133062:930:0;;-1:-1:-1;;;;;133062:930:0:i;131385:298::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;131385:298:0;;;;;;-1:-1:-1;;;;;131385:298:0;;:::i;132356:138::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;132356:138:0;;:::i;27579:69::-;;;:::i;113671:29::-;;;:::i;113211:19::-;;;:::i;119503:248::-;119670:73;119679:10;119691:6;119699:11;119712:16;119730:12;;119670:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;119670:8:0;;-1:-1:-1;;;119670:73:0:i;:::-;119503:248;;;;;:::o;135033:1483::-;28198:9;;135237:7;;-1:-1:-1;;;;;28198:9:0;28184:10;:23;28176:32;;;;;;135629:14;135646:65;135687:23;;135646:36;135664:17;;135646:13;:17;;:36;;;;:::i;:::-;:40;:65;:40;:65;:::i;:::-;135629:82;;135731:35;135740:17;;135759:6;135731:8;:35::i;:::-;135722:44;;135779:22;135804:34;135834:3;135804:25;135815:13;;135804:6;:10;;:25;;;;:::i;:34::-;-1:-1:-1;;;;;135890:27:0;;;135849;135890;;;:17;:27;;;;;;;;;135879:39;;:10;:39;;;;;135933:25;;;;135779:59;;-1:-1:-1;135879:39:0;135933:25;:41;135929:255;;136007:25;;;;136067:16;;135991:93;;;-1:-1:-1;;;135991:93:0;;;;;;;;;;;;;;;;-1:-1:-1;;;;;136007:25:0;;;;135991:59;;:93;;;;;136007:25;;135991:93;;;;;;;;136007:25;;135991:93;;;5:2:-1;;;;30:1;27;20:12;5:2;135991:93:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;135991:93:0;;;;135929:255;;;136136:16;;;;:36;;136157:14;136136:36;:20;:36;:::i;:::-;136117:16;;;:55;135929:255;136205:26;:6;136216:14;136205:26;:10;:26;:::i;:::-;136196:35;;136242:18;136263:31;:29;:31::i;:::-;136384:16;:28;;;136242:52;-1:-1:-1;136423:17:0;:15;:17::i;:::-;136458:50;136473:10;136485:6;136493:8;136503:4;136458:14;:50::i;:::-;136451:57;135033:1483;-1:-1:-1;;;;;;;;;;135033:1483:0:o;132760:111::-;4728:9;:7;:9::i;:::-;4720:18;;;;;;132837:17;:26;132760:111::o;114000:28::-;;;;:::o;113922:27::-;;;;:::o;113378:31::-;;;;:::o;130336:134::-;4728:9;:7;:9::i;:::-;4720:18;;;;;;-1:-1:-1;;;;;130406:22:0;;130398:31;;;;;;130440:5;:22;;-1:-1:-1;;;;;;130440:22:0;-1:-1:-1;;;;;130440:22:0;;;;;;;;;;130336:134::o;130557:231::-;4728:9;:7;:9::i;:::-;4720:18;;;;;;130664:1;130649:12;:16;130641:25;;;;;;130677:6;;130717:18;;130677:59;;;-1:-1:-1;;;130677:59:0;;;;;;;;;;;;;;;;-1:-1:-1;;;;;130677:6:0;;;;:25;;:59;;;;;:6;;:59;;;;;;;;:6;;:59;;;5:2:-1;;;;30:1;27;20:12;5:2;130677:59:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;;130747:18:0;:33;;;;-1:-1:-1;130557:231:0:o;130168:134::-;130254:11;;:40;;;-1:-1:-1;;;130254:40:0;;-1:-1:-1;;;;;130254:40:0;;;;;;;130227:7;130254:40;;;;;;;;130227:7;;130254:11;;:31;;:40;;;;;;;;;;;;;;;:11;:40;;;5:2:-1;;;;30:1;27;20:12;5:2;130254:40:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;130254:40:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;130254:40:0;;-1:-1:-1;130168:134:0;;;;:::o;139827:1009::-;139882:11;116027:30;116045:11;116027:17;:30::i;:::-;139948:13;139914:23;;;;:10;:23;;;;;:30;;;-1:-1:-1;;;139914:30:0;;;;:47;;;;;;;;;139906:83;;;;;-1:-1:-1;;;139906:83:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;140008:23;;;;:10;:23;;;;;:41;;;:46;140000:86;;;;;-1:-1:-1;;;140000:86:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;140123:12;;140099:21;140154:23;;;:10;:23;;;;;:32;;;:49;-1:-1:-1;140154:49:0;140146:84;;;;;-1:-1:-1;;;140146:84:0;;;;;;;;;;;;-1:-1:-1;;;140146:84:0;;;;;;;;;;;;;;;140243:14;140260:23;;;:10;:23;;;;;:30;140319:10;;140309:20;;;140301:29;;;;;;140343:24;140386:23;;;:10;:23;;;;;:39;;;-1:-1:-1;;;;;140386:39:0;:55;140382:180;;140493:23;;;;:10;:23;;;;;;;;:39;;;140477:73;;-1:-1:-1;;;140477:73:0;;;;-1:-1:-1;;;;;140493:39:0;;;;140477:71;;:73;;;;;140493:23;;140477:73;;;;;;;;;140493:39;140477:73;;;5:2:-1;;;;30:1;27;20:12;5:2;140477:73:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;140477:73:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;140477:73:0;;-1:-1:-1;140382:180:0;140637:58;140659:28;:6;140670:16;140659:28;:10;:28;:::i;:::-;140690:1;140693;140637:14;:58::i;:::-;140708:23;;;;:10;:23;;;;;;:30;;;:46;;-1:-1:-1;;;;140708:46:0;-1:-1:-1;;;140708:46:0;;;140765:6;;;140797:30;;;140765:63;;-1:-1:-1;;;140765:63:0;;;;;;;;-1:-1:-1;;;;;140797:30:0;;;140765:63;;;;;;:6;;;:18;;:63;;;;;;;;;;;140708:23;140765:6;:63;;;5:2:-1;;;;30:1;27;20:12;5:2;140765:63:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;140765:63:0;;;;116068:1;;;139827:1009;;:::o;114115:31::-;;;;:::o;125761:114::-;4728:9;:7;:9::i;:::-;4720:18;;;;;;125839:12;:28;125761:114::o;113725:38::-;;;;:::o;115146:60::-;;;;;;;;;;;;;;;;;;;:::o;134405:620::-;134468:4;134511:23;;;:10;:23;;;;;:39;;;;134589:41;;;;134658:30;;134715;;;;;134780:12;;134511:39;;134589:41;;-1:-1:-1;;;134715:30:0;;;;;;134813:10;;;;;:85;;-1:-1:-1;134841:20:0;;;;;:56;;;134884:13;134865:15;:32;;134841:56;134813:163;;;;-1:-1:-1;134916:22:0;;;:59;;;134962:13;134942:17;:33;134916:59;134813:203;;;;-1:-1:-1;135003:13:0;134993:6;:23;;;;;;;;;134813:203;134805:212;134405:620;-1:-1:-1;;;;;;;134405:620:0:o;128181:1160::-;27093:17;:15;:17::i;:::-;128323:11;116027:30;116045:11;116027:17;:30::i;:::-;128355:23;;;;:10;:23;;;;;:41;;;:46;128347:78;;;;;-1:-1:-1;;;128347:78:0;;;;;;;;;;;;-1:-1:-1;;;128347:78:0;;;;;;;;;;;;;;;128442:10;;128438:130;;128477:5;;:53;;;-1:-1:-1;;;128477:53:0;;128496:10;128477:53;;;;128516:4;128477:53;;;;;;;;;;;;-1:-1:-1;;;;;128477:5:0;;;;:18;;:53;;;;;;;;;;;;;;;:5;;:53;;;5:2:-1;;;;30:1;27;20:12;5:2;128477:53:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;128477:53:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;128477:53:0;128469:87;;;;;-1:-1:-1;;;128469:87:0;;;;;;;;;;;;-1:-1:-1;;;128469:87:0;;;;;;;;;;;;;;;128584:12;128580:382;;;128633:23;;;;:10;:23;;;;;:30;;;128622:42;;:6;;:42;:10;:42;:::i;:::-;128679:20;128702:23;;;:10;:23;;;;;:39;;;128613:51;;-1:-1:-1;;;;;;128702:39:0;128760:28;;128756:146;;128818:68;128845:12;-1:-1:-1;;;;;128829:54:0;;:56;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;128829:56:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;128829:56:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;128829:56:0;128818:6;;:68;:10;:68;:::i;:::-;128809:77;;128756:146;-1:-1:-1;128949:1:0;128916:23;;;:10;:23;;;;;:30;;:34;128580:382;128999:11;;128974:22;;128999:23;;129015:6;128999:23;:15;:23;:::i;:::-;129033:11;:28;;;129105:23;;;;:10;:23;;;;;:30;128974:48;;-1:-1:-1;129105:42:0;;129140:6;129105:42;:34;:42;:::i;:::-;129072:23;;;;:10;:23;;;;;:75;;;;129160:36;;129182:6;;129072:23;129160:14;:36::i;:::-;129209:6;;:34;;;-1:-1:-1;;;129209:34:0;;;;;;;;;;-1:-1:-1;;;;;129209:6:0;;;;:21;;:34;;;;;:6;;:34;;;;;;;;:6;;:34;;;5:2:-1;;;;30:1;27;20:12;5:2;129209:34:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;129254:6:0;;;129286:23;;;:10;:23;;;;;;:30;129254:79;;-1:-1:-1;;;129254:79:0;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;129254:6:0;;;;-1:-1:-1;129254:18:0;;-1:-1:-1;129254:79:0;;;;;;;;;;;:6;;:79;;;5:2:-1;;;;30:1;27;20:12;125021:558:0;125079:11;116027:30;116045:11;116027:17;:30::i;:::-;125111:29;;;;:16;:29;;;;;:36;:41;125103:81;;;;;-1:-1:-1;;;125103:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;125259:1;125217:23;;;:10;:23;;;;;:39;;;:43;;;;:110;;-1:-1:-1;125281:23:0;;;;:10;:23;;;;;:41;;;:46;125217:110;:231;;;;-1:-1:-1;125383:13:0;125349:23;;;;:10;:23;;;;;:30;;;-1:-1:-1;;;125349:30:0;;;;:47;;;;;;;;;:98;;;-1:-1:-1;125434:13:0;125400:23;;;;:10;:23;;;;;:30;;;-1:-1:-1;;;125400:30:0;;;;:47;;;;;;;;;125349:98;125195:264;;;;;;125492:12;;125472:17;;125492:19;;125509:1;125492:19;:16;:19;:::i;:::-;125472:39;;125539:32;125548:11;125561:9;125539:8;:32::i;:::-;116068:1;125021:558;;:::o;113299:29::-;;;-1:-1:-1;;;;;113299:29:0;;:::o;114055:28::-;;;;:::o;114963:47::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;114963:47:0;;;;;;;;-1:-1:-1;;;114963:47:0;;;;;:::o;115053:52::-;;;;;;;;;;;;;:::o;113621:25::-;;;;:::o;145518:487::-;26823:10;;;;;-1:-1:-1;;;;;26823:10:0;26801;:33;26779:121;;;;-1:-1:-1;;;26779:121:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;145708:20;145731:23;;;:10;:23;;;;;:39;;;-1:-1:-1;;;;;145731:39:0;145789:28;145781:83;;;;-1:-1:-1;;;145781:83:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;145948:49;;;-1:-1:-1;;;145948:49:0;;-1:-1:-1;;;;;145948:49:0;;;;;;;;;;;;;;;;;;;;;;145924:12;;145948:20;;;;;:49;;;;;145875:30;;145948:49;;;;;;;145875:30;145948:20;:49;;;5:2:-1;;;;30:1;27;20:12;5:2;145948:49:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;145948:49:0;;;;26911:1;;145518:487;;;;:::o;119759:262::-;119820:7;-1:-1:-1;;;;;119844:20:0;;;;:56;;-1:-1:-1;119868:11:0;;:27;;;-1:-1:-1;;;119868:27:0;;-1:-1:-1;;;;;119868:27:0;;;;;;;;;:11;;;;;:21;;:27;;;;;;;;;;;;;;:11;:27;;;5:2:-1;;;;30:1;27;20:12;5:2;119868:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;119868:27:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;119868:27:0;:32;119844:56;119840:97;;;-1:-1:-1;119924:1:0;119917:8;;119840:97;119965:11;;:40;;;-1:-1:-1;;;119965:40:0;;-1:-1:-1;;;;;119965:40:0;;;;;;;119954:52;119965:40;;;;;;;;119954:10;;119965:11;;;;;:31;;:40;;;;;;;;;;;;;;:11;:40;;;5:2:-1;;;;30:1;27;20:12;5:2;119965:40:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;119965:40:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;119965:40:0;119954:52;;119965:40;119954:52;;;;;;;;-1:-1:-1;119954:52:0;:59;;119759:262;-1:-1:-1;;119759:262:0:o;113770:32::-;;;;:::o;113811:33::-;;;;:::o;126697:495::-;27093:17;:15;:17::i;:::-;126939:18;;126911:25;:23;:25::i;:::-;:46;126903:92;;;;-1:-1:-1;;;126903:92:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;127023:10;;127014:6;:19;127006:57;;;;;-1:-1:-1;;;127006:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;127074:44;127092:4;127098:11;127111:6;127074:17;:44::i;:::-;127129:55;127139:4;127145:6;127153:16;127171:12;127129:9;:55::i;:::-;;126697:495;;;;;:::o;115308:51::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;115308:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;115308:51:0;;;-1:-1:-1;;;115308:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;114267:29::-;;;;;;:::o;113890:25::-;;;;:::o;134251:146::-;134323:7;134350:23;;;:10;:23;;;;;:39;;;-1:-1:-1;;;;;134350:39:0;;134251:146::o;26600:29::-;;;;;;-1:-1:-1;;;;;26600:29:0;;:::o;138352:1467::-;138452:8;;;138443:46;;;-1:-1:-1;;;138443:46:0;;;;138415:7;;138493:10;;-1:-1:-1;;;;;138452:8:0;;138443:44;;:46;;;;;;;;;;;138452:8;138443:46;;;5:2:-1;;;;30:1;27;20:12;5:2;138443:46:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;138443:46:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;138443:46:0;-1:-1:-1;;;;;138443:60:0;;138435:105;;;;;-1:-1:-1;;;138435:105:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;138551:43;138597:38;:29;:17;:27;:29::i;:::-;:36;:38::i;:::-;138551:84;-1:-1:-1;138646:16:0;;;;138742:930;138766:16;:23;138762:1;:27;138742:930;;;138811:36;138850:28;:16;138867:1;138850:19;;;;;;;;;;;;;;:26;:28::i;:::-;138811:67;;138893:19;138915:21;:9;138925:1;138915:12;;;;;;;;;;;;;;:19;:21::i;:::-;138893:43;;138951:15;138969:21;:9;138979:1;138969:12;;;;;;;:21;138951:39;-1:-1:-1;139019:24:0;:11;138951:39;139019:24;:15;:24;:::i;:::-;139115:3;139064:23;;;:10;:23;;;;;:39;;;139005:38;;-1:-1:-1;;;;;;139064:39:0;:55;139060:345;;139140:24;139183:23;;;:10;:23;;;;;;;;:39;;;;139252:30;;139167:164;;-1:-1:-1;;;139167:164:0;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;139183:39:0;;;;139167:62;;:164;;;;;;;;;;;139140:24;139183:39;139167:164;;;5:2:-1;;;;30:1;27;20:12;5:2;139167:164:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;139167:164:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;139167:164:0;;-1:-1:-1;139360:29:0;:7;139167:164;139360:29;:11;:29;:::i;:::-;139350:39;;139060:345;;139454:23;;;;:10;:23;;;;;:30;:43;;139489:7;139454:43;:34;:43;:::i;:::-;139421:23;;;;:10;:23;;;;;:76;139516:12;;:24;;:9;;139526:1;;139516:12;;;;;;;;;;;;:22;:24::i;:::-;139512:149;;;139576:39;139593:21;139599:11;139612:1;139593:5;:21::i;:::-;139576:12;;:39;:16;:39;:::i;:::-;139634:11;;;;;139561:54;-1:-1:-1;139512:149:0;-1:-1:-1;;;138791:3:0;;138742:930;;;-1:-1:-1;139711:69:0;139734:29;:11;139750:12;139734:29;:15;:29;:::i;:::-;139726:38;;139767:9;139766:10;;139778:1;139711:14;:69::i;:::-;139800:11;138352:1467;-1:-1:-1;;;;;138352:1467:0:o;117827:118::-;117909:11;;:28;;;-1:-1:-1;;;117909:28:0;;;;;;;;;;117882:7;;-1:-1:-1;;;;;117909:11:0;;:19;;:28;;;;;;;;;;;;;;:11;:28;;;5:2:-1;;;;30:1;27;20:12;117681:138:0;27093:17;:15;:17::i;:::-;117772:39;117790:4;117796:11;117809:1;117772:17;:39::i;:::-;117681:138;;:::o;146176:328::-;26823:10;;;;;-1:-1:-1;;;;;26823:10:0;26801;:33;26779:121;;;;-1:-1:-1;;;26779:121:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;146345:11;:38;;-1:-1:-1;;;;;146345:38:0;;;-1:-1:-1;;;;;;146345:38:0;;;;;;;146394:6;:36;;;;;;;;;;;;;;;146441:7;:55;;;;;;;;;;;146176:328::o;118882:613::-;119117:38;;;119128:10;119117:38;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;6:49;;119117:38:0;;;;;;;119107:49;;;;;;119180:16;;-1:-1:-1;;;119107:97:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:65;;;;:49;;119173:5;;119180:16;;119198:5;;119107:97;;;;;;;;;;;;;-1:-1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;119107:97:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;119107:97:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;119107:97:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;119107:97:0;119085:162;;;;;-1:-1:-1;;;119085:162:0;;;;;;;;;;;;-1:-1:-1;;;119085:162:0;;;;;;;;;;;;;;;119314:10;119258:22;119302:23;;;:11;:23;;;;;;119283:43;;:14;;:43;:18;:43;:::i;:::-;119258:68;;119337:37;119347:10;119359:14;119337:9;:37::i;:::-;119397:10;119385:23;;;;:11;:23;;;;;;;;:40;;;119444:5;;:42;;-1:-1:-1;;;119444:42:0;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;119444:5:0;;;;:14;;:42;;;;;119385:23;119444:42;;;;;;;;:5;:42;;;5:2:-1;;;;30:1;27;20:12;5:2;119444:42:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;119444:42:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;119444:42:0;119436:51;;;;;;118882:613;;;;:::o;126306:383::-;126466:17;;126441:4;;126466:17;;126458:52;;;;;-1:-1:-1;;;126458:52:0;;;;;;;;;;;;-1:-1:-1;;;126458:52:0;;;;;;;;;;;;;;;126529:23;;;;:10;:23;;;;;:39;;;-1:-1:-1;;;;;126529:39:0;126572:10;126529:53;126521:90;;;;;-1:-1:-1;;;126521:90:0;;;;;;;;;;;;-1:-1:-1;;;126521:90:0;;;;;;;;;;;;;;;126629:5;;:52;;;-1:-1:-1;;;126629:52:0;;-1:-1:-1;;;;;126629:52:0;;;;;;;126667:4;126629:52;;;;;;;;;;;;:5;;;;;:18;;:52;;;;;;;;;;;;;;:5;;:52;;;5:2:-1;;;;30:1;27;20:12;5:2;126629:52:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;126629:52:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;126629:52:0;;126306:383;-1:-1:-1;;;;126306:383:0:o;113504:22::-;;;;:::o;5306:140::-;4728:9;:7;:9::i;:::-;4720:18;;;;;;5389:6;;5368:40;;5405:1;;-1:-1:-1;;;;;5389:6:0;;5368:40;;5405:1;;5368:40;5419:6;:19;;-1:-1:-1;;;;;;5419:19:0;;;5306:140::o;113431:27::-;;;;:::o;114226:34::-;;;;:::o;115215:46::-;;;;;;;;;;;;;:::o;113237:23::-;;;-1:-1:-1;;;;;113237:23:0;;:::o;113557:32::-;;;;:::o;134000:117::-;134083:26;;134000:117;;:::o;113857:26::-;;;;:::o;116292:1234::-;99957:6;;;;99956:7;99948:34;;;;;-1:-1:-1;;;99948:34:0;;;;;;;;;;;;-1:-1:-1;;;99948:34:0;;;;;;;;;;;;;;;99993:6;:13;;100002:4;-1:-1:-1;;99993:13:0;;;;;;-1:-1:-1;116593:37:0;;-1:-1:-1;;;;;;116593:37:0;99993:13;-1:-1:-1;;;;;116593:37:0;;;;;;;;;;;;;;116641:8;:20;;-1:-1:-1;;;;;;116641:20:0;;;;;;;;;;116672:9;:22;;;;;;;;;;116705:5;:22;;;;;;;;;;116738:11;:38;;;;;;;;;;116787:6;:36;;;;;;;;;;116834:7;:55;;;;;;;;;;;;;;116900:26;116919:6;116900:18;:26::i;:::-;-1:-1:-1;;116959:5:0;116939:16;:26;-1:-1:-1;;117006:1:0;116991:12;:16;;;117028:3;117018:7;:13;;;117085:16;117065:17;:36;117151:6;117137:10;:21;;;117187:14;:25;117267:4;117241:23;:30;117302:3;117282:17;:23;117339:1;117318:18;:22;117357:10;:14;;;117398:11;117382:13;:27;117440:13;:18;117494:17;:24;;-1:-1:-1;;117494:24:0;;;;;;-1:-1:-1;;;;116292:1234:0:o;4516:79::-;4581:6;;-1:-1:-1;;;;;4581:6:0;4516:79;:::o;4851:92::-;4929:6;;-1:-1:-1;;;;;4929:6:0;4915:10;:20;;4851:92::o;117953:85::-;118018:12;;117953:85;:::o;125637:116::-;4728:9;:7;:9::i;:::-;4720:18;;;;;;125710:35;125719:11;125732:12;;125710:8;:35::i;:::-;125637:116;:::o;129733:427::-;129797:11;116027:30;116045:11;116027:17;:30::i;:::-;129821:14;129838:23;;;:10;:23;;;;;:30;;;;129902:39;;;;;-1:-1:-1;;;;;129902:39:0;129956:28;;129952:138;;130010:68;130037:12;-1:-1:-1;;;;;130021:54:0;;:56;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;130021:56:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;130021:56:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;130021:56:0;130010:6;;:68;:10;:68;:::i;:::-;130001:77;;129952:138;130102:50;130120:11;130133:10;130145:6;130102:17;:50::i;27894:24::-;;;-1:-1:-1;;;;;27894:24:0;;:::o;122875:2138::-;27093:17;:15;:17::i;:::-;123031:23;123057:29;;;:16;:29;;;;;123119:12;;;;-1:-1:-1;;;;;123119:12:0;123166:10;:25;;;:70;;;123225:11;123195:26;123210:10;123195:14;:26::i;:::-;:41;123166:70;123144:156;;;;-1:-1:-1;;;123144:156:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;123337:12;;123452:13;;123440:7;;123422:26;;123452:13;;123422:26;:17;:26;:::i;:::-;123400:18;;;;123382:37;;:13;;:37;:17;:37;:::i;:::-;:66;;;;;;:83;;123360:165;;;;;-1:-1:-1;;;123360:165:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;123544:12;;;;-1:-1:-1;;;;;123544:12:0;123536:56;;;;;-1:-1:-1;;;123536:56:0;;;;;;;;;;;;-1:-1:-1;;;123536:56:0;;;;;;;;;;;;;;;123605:23;123631;;;:10;:23;;;;;:30;;123747:14;;123795:39;;;;;123631:30;;;;-1:-1:-1;;;;;123795:39:0;123851:28;;123847:145;;123913:67;123948:12;-1:-1:-1;;;;;123932:45:0;;:47;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;123932:47:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;123932:47:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;123932:47:0;123913:14;;:67;:18;:67;:::i;:::-;123896:84;;123847:145;124066:13;124048:14;:31;;:81;;;;-1:-1:-1;124083:23:0;;;;:10;:23;;;;;:41;;;:46;124048:81;124044:801;;;124154:5;;:42;;;-1:-1:-1;;;124154:42:0;;-1:-1:-1;;;;;124154:42:0;;;;;;;;;;;;;;;:5;;;;;:14;;:42;;;;;;;;;;;;;;:5;;:42;;;5:2:-1;;;;30:1;27;20:12;5:2;124154:42:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;124154:42:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;124154:42:0;124146:72;;;;;-1:-1:-1;;;124146:72:0;;;;;;;;;;;;-1:-1:-1;;;124146:72:0;;;;;;;;;;;;;;;124269:18;;;:34;;;124318:6;;:67;;;-1:-1:-1;;;124318:67:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;124318:6:0;;;;:24;;:67;;;;;:6;;:67;;;;;;;;:6;;:67;;;5:2:-1;;;;30:1;27;20:12;5:2;124318:67:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;124318:67:0;;;;124044:801;;;124443:46;124461:11;124474;124487:1;124443:17;:46::i;:::-;124504:36;124513:11;124526:13;124504:8;:36::i;:::-;124672:24;;;;;124715:20;;;124582:168;;;;;;124672:24;124582:168;;;;;-1:-1:-1;;124582:168:0;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;124582:168:0;;124610:11;;124640:13;;-1:-1:-1;;;124672:24:0;;;;;;124715:20;;124582:168;;124715:20;124582:168;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:9;:168::i;:::-;124765:6;;:68;;;-1:-1:-1;;;124765:68:0;;;;;;;;;;;;;;;;;;;;;;124557:193;;-1:-1:-1;;;;;;124765:6:0;;;;:24;;:68;;;;;:6;;:68;;;;;;;;:6;;:68;;;5:2:-1;;;;30:1;27;20:12;5:2;124765:68:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;124765:68:0;;;;124044:801;;124876:18;;;;;124855;124912:29;;;:16;:29;;;;;124905:36;;;;;;;;;;;;;;-1:-1:-1;;;;;;124905:36:0;;;124876:18;;124912:29;124905:36;;;;124855:18;124905:36;:::i;:::-;-1:-1:-1;;124952:29:0;;;;:16;:29;;;;;;:40;;:53;;;;-1:-1:-1;;;;;;;;122875:2138:0:o;115481:31::-;;;;:::o;132502:250::-;4728:9;:7;:9::i;:::-;4720:18;;;;;;132585:6;;132633:13;;132585:62;;;-1:-1:-1;;;132585:62:0;;;;;;;;;;;;;;;;-1:-1:-1;;;;;132585:6:0;;;;:29;;:62;;;;;:6;;:62;;;;;;;;:6;;:62;;;5:2:-1;;;;30:1;27;20:12;5:2;132585:62:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;132585:62:0;;;;132686:3;132666:16;:23;;132658:43;;;;;-1:-1:-1;;;132658:43:0;;;;;;;;;;;;-1:-1:-1;;;132658:43:0;;;;;;;;;;;;;;;132712:13;:32;132502:250::o;131691:221::-;131783:23;;;;:10;:23;;;;;:39;;;-1:-1:-1;;;;;131783:39:0;131826:10;131783:53;131775:90;;;;;-1:-1:-1;;;131775:90:0;;;;;;;;;;;;-1:-1:-1;;;131775:90:0;;;;;;;;;;;;;;;131876:28;131891:6;131899:1;131902;131876:14;:28::i;130796:192::-;4728:9;:7;:9::i;:::-;4720:18;;;;;;130898:1;130888:7;:11;130880:56;;;;;-1:-1:-1;;;130880:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;130947:23;:33;130796:192::o;134125:118::-;134214:14;:21;134125:118;:::o;120029:2838::-;27093:17;:15;:17::i;:::-;120222:30;120255:23;;;:10;:23;;;;;:30;;120320:41;;;;;:46;:77;;;;-1:-1:-1;120370:27:0;;;120320:77;120298:159;;;;;-1:-1:-1;;;120298:159:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;120514:10;120468:25;120496:29;;;:17;:29;;;;;;;;;;120612:11;;:33;;-1:-1:-1;;;120612:33:0;;;;;;;;;;;120496:29;;-1:-1:-1;;;;;120612:11:0;;;;:21;;:33;;;;;120496:29;;120612:33;;;;;:11;:33;;;5:2:-1;;;;30:1;27;20:12;5:2;120612:33:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;120612:33:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;120612:33:0;:38;:135;;;;;-1:-1:-1;;120704:17:0;:43;;120612:135;120590:205;;;;;-1:-1:-1;;;120590:205:0;;;;;;;;;;;;-1:-1:-1;;;120590:205:0;;;;;;;;;;;;;;;120832:12;;120886:19;;121001:25;;;:66;;;121054:13;121030:20;:37;;121001:66;120993:94;;;;;-1:-1:-1;;;120993:94:0;;;;;;;;;;;;-1:-1:-1;;;120993:94:0;;;;;;;;;;;;;;;121685:13;;121655:7;;:26;;121685:13;121655:26;:11;:26;:::i;:::-;121612:23;;;;:10;:23;;;;;:39;;;121594:58;;:13;;:58;:17;:58;:::i;:::-;:87;;;;;;121593:105;121571:177;;;;;-1:-1:-1;;;121571:177:0;;;;;;;;;;;;-1:-1:-1;;;121571:177:0;;;;;;;;;;;;;;;121761:22;121839:23;;;:10;:23;;;;;:39;;;121786:22;;-1:-1:-1;;;;;121839:39:0;121895:25;;121891:139;;121954:64;121989:9;-1:-1:-1;;;;;121973:42:0;;:44;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;121973:44:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;121954:64:0;121937:81;;121891:139;122042:23;122068:29;;;:16;:29;;;;;122139:14;;122183:46;122192:14;122139;122183:8;:46::i;:::-;122166:63;;122267:6;122250:14;:23;122242:51;;;;;-1:-1:-1;;;122242:51:0;;;;;;;;;;;;-1:-1:-1;;;122242:51:0;;;;;;;;;;;;;;;122312:5;;:53;;;-1:-1:-1;;;122312:53:0;;122331:10;122312:53;;;;122351:4;122312:53;;;;;;;;;;;;-1:-1:-1;;;;;122312:5:0;;;;:18;;:53;;;;;;;;;;;;;;;:5;;:53;;;5:2:-1;;;;30:1;27;20:12;5:2;122312:53:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;122312:53:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;122312:53:0;122304:88;;;;;-1:-1:-1;;;122304:88:0;;;;;;;;;;;;-1:-1:-1;;;122304:88:0;;;;;;;;;;;;;;;122441:25;;122437:138;;122491:5;;122506:12;;;;122491:50;;;-1:-1:-1;;;122491:50:0;;-1:-1:-1;;;;;122506:12:0;;;122491:50;;;;;;;;;;;;:5;;;;;:14;;:50;;;;;;;;;;;;;;:5;;:50;;;5:2:-1;;;;30:1;27;20:12;5:2;122491:50:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;122491:50:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;122491:50:0;122483:80;;;;;-1:-1:-1;;;122483:80:0;;;;;;;;;;;;-1:-1:-1;;;122483:80:0;;;;;;;;;;;;;;;122618:23;;;122652:12;;;:25;;122667:10;-1:-1:-1;;;;;;122652:25:0;;;;-1:-1:-1;;;;122688:44:0;-1:-1:-1;;;122688:44:0;;;;;;;122743:36;:20;;;122766:13;;122743:36;:::i;:::-;;122792:6;;;;;;;;;-1:-1:-1;;;;;122792:6:0;-1:-1:-1;;;;;122792:22:0;;122815:11;122828:22;122852:6;122792:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;122792:67:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;122792:67:0;;;;27121:1;;;;;;;;120029:2838;;;;;:::o;27656:73::-;26823:10;;;;;-1:-1:-1;;;;;26823:10:0;26801;:33;26779:121;;;;-1:-1:-1;;;26779:121:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27707:14;:12;:14::i;:::-;27656:73::o;118046:99::-;118121:16;;118046:99;:::o;146013:155::-;26823:10;;;;;-1:-1:-1;;;;;26823:10:0;26801;:33;26779:121;;;;-1:-1:-1;;;26779:121:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;146108:5;;:35;;;-1:-1:-1;;;146108:35:0;;-1:-1:-1;;;;;146108:35:0;;;;;;;;;;;;;;;:5;;;;;:14;;:35;;;;;;;;;;;;;;:5;;:35;;;5:2:-1;;;;30:1;27;20:12;5:2;146108:35:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;146108:35:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;146108:35:0;146100:60;;;;;-1:-1:-1;;;146100:60:0;;;;;;;;;;;;-1:-1:-1;;;146100:60:0;;;;;;;;;;;;;;132879:175;4728:9;:7;:9::i;:::-;4720:18;;;;;;132979:10;:24;;;;133014:14;:32;132879:175::o;125883:415::-;126062:8;;;126053:46;;;-1:-1:-1;;;126053:46:0;;;;126014:4;;126103:10;;-1:-1:-1;;;;;126062:8:0;;126053:44;;:46;;;;;;;;;;;126062:8;126053:46;;;5:2:-1;;;;30:1;27;20:12;5:2;126053:46:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;126053:46:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;126053:46:0;-1:-1:-1;;;;;126053:60:0;;;:134;;-1:-1:-1;126134:23:0;;;;:10;:23;;;;;:39;;;-1:-1:-1;;;;;126134:39:0;126177:10;126134:53;126053:134;126031:208;;;;;-1:-1:-1;;;126031:208:0;;;;;;;;;;;;-1:-1:-1;;;126031:208:0;;;;;;;;;;;;;;;126257:5;;:33;;;-1:-1:-1;;;126257:33:0;;-1:-1:-1;;;;;126257:33:0;;;;;;;;;;;;;;;:5;;;;;:14;;:33;;;;;;;;;;;;;;:5;;:33;;;5:2:-1;;;;30:1;27;20:12;113335:36:0;;;-1:-1:-1;;;;;113335:36:0;;:::o;131038:212::-;4728:9;:7;:9::i;:::-;4720:18;;;;;;131137:1;131125:9;:13;131117:22;;;;;;131150:6;;131184:17;;131150:52;;;-1:-1:-1;;;131150:52:0;;;;;;;;;;;;;;;;-1:-1:-1;;;;;131150:6:0;;;;:22;;:52;;;;;:6;;:52;;;;;;;;:6;;:52;;;5:2:-1;;;;30:1;27;20:12;5:2;131150:52:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;;131213:17:0;:29;;;;-1:-1:-1;131038:212:0:o;113956:37::-;;;;:::o;27027:18::-;;;;;;:::o;146512:414::-;146624:10;146584:19;146606:29;;;:17;:29;;;;;;146654:24;146606:29;146654:11;:24::i;:::-;146646:52;;;;;-1:-1:-1;;;146646:52:0;;;;;;;;;;;;-1:-1:-1;;;146646:52:0;;;;;;;;;;;;;;;146711:20;146734:23;;;:10;:23;;;;;:39;;;-1:-1:-1;;;;;146734:39:0;146792:28;146784:63;;;;;-1:-1:-1;;;146784:63:0;;;;;;;;;;;;-1:-1:-1;;;146784:63:0;;;;;;;;;;;;;;;146860:58;;;-1:-1:-1;;;146860:58:0;;;;;;;;;;;-1:-1:-1;;;;;146860:46:0;;;;;:58;;;;;-1:-1:-1;;146860:58:0;;;;;;;-1:-1:-1;146860:46:0;:58;;;5:2:-1;;;;30:1;27;20:12;5:2;146860:58:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;146860:58:0;;;;146512:414;;;:::o;115414:58::-;;;;;;;;;;;;;:::o;127200:937::-;127261:11;116027:30;116045:11;116027:17;:30::i;:::-;127285:25;127313:23;;;:10;:23;;;;;:41;;;127448:21;;;;;:97;;-1:-1:-1;127533:12:0;;127512:16;;127490:39;;:17;;:39;:21;:39;:::i;:::-;:55;;127448:97;:167;;;;-1:-1:-1;127600:15:0;127566:23;;;;:10;:23;;;;;:30;;;-1:-1:-1;;;127566:30:0;;;;:49;;;;;;;;;;127448:167;127426:200;;;;;;127639:14;127656:23;;;:10;:23;;;;;:30;127722:11;;127656:30;;127639:14;127722:23;;127656:30;127722:23;:15;:23;:::i;:::-;127756:11;:28;;;127797:11;;:29;;;-1:-1:-1;;;127797:29:0;;;;;;;;;;127697:48;;-1:-1:-1;;;;;;127797:11:0;;;;:16;;:29;;;;;:11;;:29;;;;;;;;:11;;:29;;;5:2:-1;;;;30:1;27;20:12;5:2;127797:29:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;;127839:49:0;127857:23;;;:10;:23;;;;;;;;:30;;;;-1:-1:-1;;;;;127857:30:0;;;127839:49;;:17;:49;;;;;-1:-1:-1;;127839:74:0;;127924:23;;;;;;:30;;:48;;-1:-1:-1;;;;127924:48:0;-1:-1:-1;;;127924:48:0;;;127957:15;127991:5;:34;;-1:-1:-1;;;127991:34:0;;128006:10;127991:34;;;;;;;;;;;;:5;;;-1:-1:-1;127991:14:0;;:34;;;;;;;;;;;;;:5;:34;;;5:2:-1;;;;30:1;27;20:12;5:2;127991:34:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;127991:34:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;127991:34:0;127983:68;;;;;-1:-1:-1;;;127983:68:0;;;;;;;;;;;;-1:-1:-1;;;127983:68:0;;;;;;;;;;;;;;;128062:6;;:67;;;-1:-1:-1;;;128062:67:0;;128081:10;128062:67;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;128062:6:0;;;;:18;;:67;;;;;:6;;:67;;;;;;;;:6;;:67;;;5:2:-1;;;;30:1;27;20:12;115112:27:0;;;;;;:::o;131920:378::-;4728:9;:7;:9::i;:::-;4720:18;;;;;;132017:1;132004:10;:14;131996:23;;;;;;132030:6;;132071:7;;132030:49;;;-1:-1:-1;;;132030:49:0;;;;;;;;;;;;;;;;-1:-1:-1;;;;;132030:6:0;;;;:28;;:49;;;;;:6;;:49;;;;;;;;:6;;:49;;;5:2:-1;;;;30:1;27;20:12;5:2;132030:49:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;;132090:7:0;:20;;;-1:-1:-1;132121:16:0;:29;;;132177:17;132100:10;132192:1;132177:17;:14;:17;:::i;:::-;132161:13;:33;;;132259:12;;:31;;;:16;:31;:::i;:::-;132237:19;:53;-1:-1:-1;131920:378:0:o;28374:210::-;4728:9;:7;:9::i;:::-;4720:18;;;;;;-1:-1:-1;;;;;28457:26:0;;28449:35;;;;;;28517:9;;28500:41;;-1:-1:-1;;;;;28500:41:0;;;;28517:9;;28500:41;;28517:9;;28500:41;28552:9;:24;;-1:-1:-1;;;;;;28552:24:0;-1:-1:-1;;;;;28552:24:0;;;;;;;;;;28374:210::o;118153:131::-;118219:7;118246:23;;;:10;:23;;;;;:30;;118153:131::o;113267:25::-;;;-1:-1:-1;;;;;113267:25:0;;:::o;117534:112::-;26823:10;;;;;-1:-1:-1;;;;;26823:10:0;26801;:33;26779:121;;;;-1:-1:-1;;;26779:121:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;117611:17;:27;;-1:-1:-1;;117611:27:0;;;;;;;;;;117534:112::o;5623:109::-;4728:9;:7;:9::i;:::-;4720:18;;;;;;5696:28;5715:8;5696:18;:28::i;133062:930::-;133150:11;116027:30;116045:11;116027:17;:30::i;:::-;133174:14;133191:26;133204:12;133191;:26::i;:::-;133174:43;-1:-1:-1;;;;;;133236:22:0;;;;;;:56;;-1:-1:-1;;;;;;133262:25:0;;;;;;:17;:25;;;;;;:30;133236:56;133228:83;;;;;-1:-1:-1;;;133228:83:0;;;;;;;;;;;;-1:-1:-1;;;133228:83:0;;;;;;;;;;;;;;;133348:12;;133451:17;;133324:21;133410:36;;;:23;:36;;;;;;:59;;;:40;:59;:::i;:::-;133393:13;:76;;133371:152;;;;;-1:-1:-1;;;133371:152:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;133536:21;133560:23;;;:10;:23;;;;;;;;:30;;;;;133633:6;;:72;;-1:-1:-1;;;133633:72:0;;;;;;;;-1:-1:-1;;;;;133560:30:0;;;133633:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;133560:30;;133633:6;;;;;:22;;133560:23;;:30;;133633:72;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;133633:72:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;133633:72:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;;;;;;;133718:32:0;;;;;;;:17;:32;;;;;;;;-1:-1:-1;;133718:57:0;;133786:25;;;;;;;;;;:39;;;133836:23;;;:10;:23;;;;;:30;;:39;;-1:-1:-1;;;;;;133836:39:0;;;;;;;-1:-1:-1;133932:23:0;:36;;;;:52;;;;-1:-1:-1;;133062:930:0:o;131385:298::-;4728:9;:7;:9::i;:::-;4720:18;;;;;;131556:4;-1:-1:-1;;;;;131501:60:0;131517:18;-1:-1:-1;;;;;131501:41:0;;:43;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;131501:43:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;131501:43:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;131501:43:0;-1:-1:-1;;;;;131501:60:0;;131493:111;;;;-1:-1:-1;;;131493:111:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;131615:23;;;;:10;:23;;;;;;:39;;:60;;-1:-1:-1;;;;;;131615:60:0;-1:-1:-1;;;;;131615:60:0;;;;;;;;;131385:298::o;132356:138::-;4728:9;:7;:9::i;:::-;4720:18;;;;;;132453:12;;:33;;132470:15;132453:33;:16;:33;:::i;27579:69::-;26823:10;;;;;-1:-1:-1;;;;;26823:10:0;26801;:33;26779:121;;;;-1:-1:-1;;;26779:121:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27628:12;:10;:12::i;113671:29::-;;;;:::o;113211:19::-;;;-1:-1:-1;;;;;113211:19:0;;:::o;2078:433::-;2136:7;2380:6;2376:47;;-1:-1:-1;2410:1:0;2403:8;;2376:47;2447:5;;;2451:1;2447;:5;:1;2471:5;;;;;:10;2463:19;;;;;;2502:1;-1:-1:-1;2078:433:0;;;;;:::o;2646:303::-;2704:7;2803:1;2799;:5;2791:14;;;;;;2816:9;2832:1;2828;:5;;;;;;;2646:303;-1:-1:-1;;;;2646:303:0:o;1265:106::-;1323:7;1354:1;1350;:5;:13;;1362:1;1350:13;;;-1:-1:-1;1358:1:0;;1343:20;-1:-1:-1;1265:106:0:o;3325:150::-;3383:7;3415:5;;;3439:6;;;;3431:15;;;;;3087:150;3145:7;3178:1;3173;:6;;3165:15;;;;;;-1:-1:-1;3203:5:0;;;3087:150::o;143980:374::-;144051:12;;144027:21;144094:20;144051:12;144112:1;144094:20;:17;:20;:::i;:::-;144074:40;;144127:26;;:::i;:::-;-1:-1:-1;144156:32:0;;;;:21;:32;;;;;;;;144127:61;;;;;;;;;;;;;;;;;;;;;;;;;;144199:54;;144127:61;144199:14;:54::i;:::-;-1:-1:-1;144273:36:0;;;;:21;:36;;;;;144266:43;;;;;;;;;144322:12;:24;143980:374::o;136524:1820::-;136692:7;;;;136843:1207;136866:4;:11;136862:1;:15;;;136843:1207;;;136903:14;136920:19;;:8;136940:27;136955:4;136940:27;;;136964:2;136940:14;:27::i;:::-;136920:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;136920:48:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;136920:48:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;136920:48:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;136920:48:0;-1:-1:-1;;;;;137005:25:0;;;136983:19;137005:25;;;:17;136920:48;137005:25;;;;;136920:48;;-1:-1:-1;137108:17:0;;;;137104:935;;;137146:5;;;;137104:935;137177:24;137189:11;137177;:24::i;:::-;:44;;;;;137214:7;-1:-1:-1;;;;;137205:16:0;:6;-1:-1:-1;;;;;137205:16:0;;137177:44;137173:866;;;137279:27;137309:23;;;:10;:23;;;;;137448:25;;;;137252:6;;-1:-1:-1;137252:6:0;;137309:23;;137279:27;-1:-1:-1;;;;;137448:25:0;137496:28;;137492:468;;137574:12;-1:-1:-1;;;;;137558:43:0;;137628:6;137661:20;137708:27;137723:11;137708:14;:27::i;:::-;137558:200;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;137558:200:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;137558:200:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;137558:200:0;;-1:-1:-1;137492:468:0;;;137816:9;:16;;;137807:25;;137874:66;137895:44;137918:20;137895:18;137906:6;137895;:10;;:18;;;;:::i;:44::-;137874:16;;;;;:66;:20;:66;:::i;:::-;137855:16;;;:85;137492:468;137996:27;:15;138016:6;137996:27;:19;:27;:::i;:::-;137978:45;;137173:866;;;;-1:-1:-1;;136884:2:0;136879:7;136843:1207;;;;138071:75;138114:31;:29;:31::i;:::-;138071:17;;:38;;138093:15;138071:38;:21;:38;:::i;:75::-;138172:12;;138062:84;;-1:-1:-1;138172:24:0;;138062:84;138172:24;:16;:24;:::i;:::-;138157:12;:39;138234:52;138284:1;138234:45;138277:1;138234:38;138270:1;138234:31;:29;:31::i;:::-;:35;:38;:35;:38;:::i;:45::-;:49;:52;:49;:52;:::i;:::-;138215:15;:71;;138207:103;;;;;-1:-1:-1;;;138207:103:0;;;;;;;;;;;;-1:-1:-1;;;138207:103:0;;;;;;;;;;;;;;;-1:-1:-1;138330:6:0;;136524:1820;-1:-1:-1;;;;;136524:1820:0:o;116085:135::-;116165:11;;:32;;;-1:-1:-1;;;116165:32:0;;;;;;;;;;116201:10;;-1:-1:-1;;;;;116165:11:0;;:19;;:32;;;;;;;;;;;;;;:11;:32;;;5:2:-1;;;;30:1;27;20:12;5:2;116165:32:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;116165:32:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;116165:32:0;-1:-1:-1;;;;;116165:46:0;;116157:55;;;;;144362:948;144499:16;144495:808;;144599:1;144590:6;:10;144586:245;;;144645:14;:21;:42;;144679:6;144645:42;:25;:42;:::i;:::-;144621:14;:66;144586:245;;;144722:1;144713:6;:10;144709:122;;;144768:14;:21;:47;;144802:11;;;;144768:47;:25;:47;:::i;:::-;144744:14;:71;144709:122;144865:1;144851:11;:15;144847:285;;;144916:26;;:52;;144955:11;144916:52;:30;:52;:::i;:::-;144887:26;:81;144847:285;;;145008:1;144994:11;:15;144990:142;;;145059:26;;:57;;145098:16;;;;145059:57;:30;:57;:::i;:::-;145030:26;:86;144990:142;144495:808;;;145164:34;;;;:21;:34;;;;;:51;;;;;;-1:-1:-1;145230:46:0;:61;;;;;;144362:948;;;:::o;27138:85::-;27198:6;;;;27197:7;27189:26;;;;;-1:-1:-1;;;27189:26:0;;;;;;;;;;;;-1:-1:-1;;;27189:26:0;;;;;;;;;;;;;;142976:996;143054:14;143071:23;;;:10;:23;;;;;:30;;143132:20;143082:11;143132:7;:20::i;:::-;143165:23;;;;:10;:23;;;;;:41;;;:53;;;143331:30;;;;143395:39;;;;;143112:40;;-1:-1:-1;143165:23:0;;-1:-1:-1;;;;;143395:39:0;143449:28;;143445:273;;143494:30;143543:12;143494:62;;143581:54;143593:14;-1:-1:-1;;;;;143593:39:0;;:41;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;143593:41:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;143581:54:0;143571:64;;143676:14;-1:-1:-1;;;;;143676:27:0;;:29;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;143676:29:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;143676:29:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;143676:29:0;;-1:-1:-1;;143445:273:0;143730:50;143748:11;143761:9;143772:7;143730:17;:50::i;:::-;143820:67;143854:16;143844:6;143837:33;143835:36;;-1:-1:-1;;143877:9:0;143820:14;:67::i;:::-;143900:6;;:64;;;-1:-1:-1;;;143900:64:0;;-1:-1:-1;;;;;143900:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;:6;;;;;:21;;:64;;;;;:6;;:64;;;;;;;:6;;:64;;;5:2:-1;;;;30:1;27;20:12;5:2;143900:64:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;143900:64:0;;;;142976:996;;;;;;;:::o;118292:408::-;118440:14;;118433:3;:21;;118425:57;;;;;-1:-1:-1;;;118425:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;118501:5;;-1:-1:-1;;;;;118501:5:0;:18;118520:10;118540:4;118547:25;:3;118555:16;118547:25;:7;:25;:::i;:::-;118501:72;;;;;;;;;;;;;-1:-1:-1;;;;;118501:72:0;-1:-1:-1;;;;;118501:72:0;;;;;;-1:-1:-1;;;;;118501:72:0;-1:-1:-1;;;;;118501:72:0;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;118501:72:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;118501:72:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;118501:72:0;118493:104;;;;;-1:-1:-1;;;118493:104:0;;;;;;;;;;;;-1:-1:-1;;;118493:104:0;;;;;;;;;;;;;;;118627:16;;:25;;118648:3;118627:25;:20;:25;:::i;:::-;118608:16;:44;118663:6;;:29;;;-1:-1:-1;;;118663:29:0;;-1:-1:-1;;;;;118663:29:0;;;;;;;;;;;;;;;:6;;;;;:18;;:29;;;;;:6;;:29;;;;;;;:6;;:29;;;5:2:-1;;;;30:1;27;20:12;141518:1450:0;141678:7;141698:14;141715:26;141728:12;141715;:26::i;:::-;141698:43;-1:-1:-1;;;;;;141760:22:0;;;;;;:56;;-1:-1:-1;;;;;;141786:25:0;;;;;;:17;:25;;;;;;:30;141760:56;141752:83;;;;;-1:-1:-1;;;141752:83:0;;;;;;;;;;;;-1:-1:-1;;;141752:83:0;;;;;;;;;;;;;;;141872:12;;141917:10;;141960:6;;142002:11;;-1:-1:-1;;;;;141960:6:0;;;;141848:21;;142002:23;;142018:6;142002:23;:15;:23;:::i;:::-;141977:48;;142050:14;142036:11;:28;;;;142103:367;;;;;;;;142160:6;142103:367;;;;142136:1;142103:367;;;;142198:13;142103:367;;;;142245:1;142103:367;;;;142271:1;142103:367;;;;142295:6;-1:-1:-1;;;;;142103:367:0;;;;;142333:16;:89;;142418:3;142333:89;;;142352:7;;142398:8;;;142352:55;;;-1:-1:-1;;;142352:55:0;;;;;;;;-1:-1:-1;;;;;142352:55:0;;;;;;;142398:8;;;142352:55;;;;;:7;;;:14;;:55;;;;;;;;;;;;;;;:7;;:55;;;5:2:-1;;;;30:1;27;20:12;5:2;142352:55:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;142352:55:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;142352:55:0;142333:89;-1:-1:-1;;;;;142103:367:0;;;;;142445:13;142103:367;;142077:23;;;;:10;:23;;;;;;;;;:393;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;142077:393:0;;;-1:-1:-1;;;;;;142077:393:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;142077:393:0;;;;-1:-1:-1;;;142077:393:0;;;;;;;;;;;;;;-1:-1:-1;;;142483:36:0;;;;:23;:36;;;;;;:52;;;142546:11;;:35;;-1:-1:-1;;;142546:35:0;;-1:-1:-1;;;;;142546:35:0;;;;;;;;;;;;;;;:11;;;;;:16;;:35;;;;;;;;;;142483:36;142546:11;:35;;;5:2:-1;;;;30:1;27;20:12;5:2;142546:35:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;;;;;;;142594:25:0;;;;;;:17;:25;;;;;:39;;;142644:36;;-1:-1:-1;142666:6:0;;142675:1;;142644:14;:36::i;:::-;142772:13;142729:16;:29;142746:11;142729:29;;;;;;;;;;;:40;;:56;;;;142796:7;-1:-1:-1;;;;;142796:17:0;;142814:6;142822:12;142836:11;142849:13;142864:6;142872:14;142796:91;;;;;;;;;;;;;-1:-1:-1;;;;;142796:91:0;-1:-1:-1;;;;;142796:91:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;142796:91:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;142796:91:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;142796:91:0;;;;142911:18;142927:1;142911:11;:15;;:18;;;;:::i;:::-;142898:10;:31;-1:-1:-1;142949:11:0;;141518:1450;-1:-1:-1;;;;;;;;141518:1450:0:o;7622:225::-;7683:14;;:::i;:::-;-1:-1:-1;7811:28:0;;;;;;;;;7819:11;;7811:28;;7776:4;7766:15;;;7811:28;;;;7622:225;;;:::o;8657:523::-;8717:16;8754:12;8761:4;8754:6;:12::i;:::-;8746:21;;;;;;8780:10;8793:14;8802:4;8793:8;:14::i;:::-;8780:27;;8818:23;8858:5;8844:20;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;8818:46;;8877:11;8905:27;8920:4;:11;;;8905:14;:27::i;:::-;8891:11;;;;:41;;-1:-1:-1;8943:12:0;;8966:181;8987:5;8983:1;:9;8966:181;;;9024:19;9036:6;9024:11;:19::i;:::-;9014:29;;9070:24;;;;;;;;9078:7;9070:24;;;;9087:6;9070:24;;;9058:6;9065:1;9058:9;;;;;;;;;;;;;;;;;:36;9119:16;;;;8994:3;;8966:181;;;-1:-1:-1;9166:6:0;;8657:523;-1:-1:-1;;;;;8657:523:0:o;10640:549::-;10725:8;;10700:4;;10725:12;;;;:30;;-1:-1:-1;10741:8:0;;10753:2;-1:-1:-1;10741:14:0;10725:30;10717:39;;;;;;10769:11;10783:27;10798:4;:11;;;10783:14;:27::i;:::-;10832:8;;10898:11;;;;;:20;;10963:13;;10769:41;;-1:-1:-1;10832:17:0;;;;;10963:13;10898:20;11054:11;;11051:2;;;11124:3;11120:2;11116:12;11111:3;11107:22;11099:6;11095:35;11085:45;;11051:2;-1:-1:-1;11175:6:0;10640:549;-1:-1:-1;;;;10640:549:0:o;10137:291::-;10225:8;;10200:4;;10237:1;10225:13;10217:22;;;;;;10286:11;;;;10350:13;;10250:11;10342:22;;10394:11;;:26;;10416:4;10394:26;;;10408:5;10394:26;10387:33;10137:291;-1:-1:-1;;;;10137:291:0:o;140844:666::-;140923:7;140986:23;;;:10;:23;;;;;:39;;;140923:7;;-1:-1:-1;;;;;140986:39:0;:55;140982:178;;141093:23;;;;:10;:23;;;;;;;;:39;;;141077:71;;-1:-1:-1;;;141077:71:0;;;;-1:-1:-1;;;;;141093:39:0;;;;141077:69;;:71;;;;;141093:23;;141077:71;;;;;;;;;141093:39;141077:71;;;5:2:-1;;;;30:1;27;20:12;5:2;141077:71:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;141077:71:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;141077:71:0;;-1:-1:-1;140982:178:0;141196:12;;141254:34;141196:12;141272:15;141254:34;:17;:34;:::i;:::-;141219:23;;;;:10;:23;;;;;;:32;;;;:69;;;;141299:30;;;:46;;-1:-1:-1;;;;141299:46:0;-1:-1:-1;;;141299:46:0;;;141356:6;;;141401:30;;;141356:76;;-1:-1:-1;;;141356:76:0;;;;;;;;;;;;;;-1:-1:-1;;;;;141401:30:0;;;141356:76;;;;;;:6;;;:16;;:76;;;;;141219:23;;141356:76;;;;;141219:23;141356:6;:76;;;5:2:-1;;;;30:1;27;20:12;5:2;141356:76:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;;141450:23:0;;;;:10;:23;;;;;:30;:52;;-1:-1:-1;141485:16:0;141450:52;:34;:52;:::i;118708:166::-;118795:16;;:28;;118816:6;118795:28;:20;:28;:::i;:::-;118776:16;:47;118834:6;;:32;;;-1:-1:-1;;;118834:32:0;;-1:-1:-1;;;;;118834:32:0;;;;;;;;;;;;;;;:6;;;;;:18;;:32;;;;;:6;;:32;;;;;;;:6;;:32;;;5:2:-1;;;;30:1;27;20:12;5:2;118834:32:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5882:187:0;-1:-1:-1;;;;;5956:22:0;;5948:31;;;;;;6016:6;;5995:38;;-1:-1:-1;;;;;5995:38:0;;;;6016:6;;5995:38;;6016:6;;5995:38;6044:6;:17;;-1:-1:-1;;;;;;6044:17:0;-1:-1:-1;;;;;6044:17:0;;;;;;;;;;5882:187::o;129349:376::-;129480:22;;:34;;129507:6;129480:34;:26;:34;:::i;:::-;129455:22;:59;129558:1;129525:23;;;:10;:23;;;;;;;;:30;;:34;;;129578:5;;:37;;-1:-1:-1;;;129578:37:0;;-1:-1:-1;;;;;129578:37:0;;;;;;;;;;;;;;;:5;;;;;:14;;:37;;;;;129525:23;;129578:37;;;;;;;;;;:5;:37;;;5:2:-1;;;;30:1;27;20:12;5:2;129578:37:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;129578:37:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;129578:37:0;129570:69;;;;;-1:-1:-1;;;129570:69:0;;;;;;;;;;;;-1:-1:-1;;;129570:69:0;;;;;;;;;;;;;;;129650:6;;129694:22;;129650:67;;;-1:-1:-1;;;129650:67:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;129650:6:0;;;;:22;;:67;;;;;:6;;:67;;;;;;;;:6;;:67;;;5:2:-1;;;;30:1;27;20:12;1082:107:0;1140:7;1172:1;1167;:6;;:14;;1180:1;1167:14;;27294:58;27339:5;27330:14;;-1:-1:-1;;27330:14:0;;;27294:58::o;145318:192::-;145380:7;145408:3;:10;145422:2;145408:16;145400:43;;;;;-1:-1:-1;;;145400:43:0;;;;;;;;;;;;-1:-1:-1;;;145400:43:0;;;;;;;;;;;;;;;-1:-1:-1;145485:14:0;;;;;;;;145318:192::o;27231:55::-;27265:6;:13;;-1:-1:-1;;27265:13:0;27274:4;27265:13;;;27231:55::o;18562:2976::-;18681:12;18746:7;18737:6;:16;18719:6;:13;:35;;18711:44;;;;;;18766:22;18830:15;;18863:2392;;;;21411:4;21405:11;21392:24;;21466:4;21455:9;21451:20;21445:4;21438:34;18823:2668;;18863:2392;19060:4;19054:11;19041:24;;19765:2;19756:7;19752:16;20224:9;20217:17;20211:4;20207:28;20170:9;20159;20155:25;20125:133;20299:7;20295:2;20291:16;20728:6;20655:9;20648:17;20642:4;20638:28;20593:9;20585:6;20581:22;20543:154;20509:252;20331:652;20792:3;20788:2;20785:11;20331:652;;;20950:9;;20939:21;;20838:4;20830:13;;;;20875;20331:652;;;-1:-1:-1;;21007:26:0;;;21231:2;21214:11;-1:-1:-1;;21210:25:0;21204:4;21197:39;-1:-1:-1;;21521:9:0;18562:2976;-1:-1:-1;;;;18562:2976:0:o;9287:342::-;9368:8;;9347:4;;9364:31;;-1:-1:-1;9390:5:0;9383:12;;9364:31;9444:11;;;;9507:13;;9408:11;9499:22;;6413:4;9548:24;;9544:55;;;9594:5;9587:12;;;;;;9544:55;-1:-1:-1;9617:4:0;;9287:342;-1:-1:-1;;;9287:342:0:o;12095:422::-;12177:8;;12156:4;;12173:27;;-1:-1:-1;12199:1:0;12192:8;;12173:27;12213:10;12226:1;12213:14;;12238:12;12267:27;12282:4;:11;;;12267:14;:27::i;:::-;12253:11;;;;12333:8;;12253:41;;;;-1:-1:-1;12319:22:0;12352:133;12369:6;12359:7;:16;12352:133;;;12411:20;12423:7;12411:11;:20::i;:::-;12466:7;;;;;12401:30;;;;12352:133;;;-1:-1:-1;12504:5:0;;12095:422;-1:-1:-1;;;12095:422:0:o;13951:552::-;14089:13;;14010:4;;14081:22;;6319:4;14130:26;;14126:369;;;14179:1;14172:8;;;;;14126:369;6366:4;14200:25;;;:83;;-1:-1:-1;6413:4:0;14230:25;;;;;:52;;-1:-1:-1;6460:4:0;14259:23;;14230:52;14196:299;;;14305:1;14298:8;;;;;14196:299;6413:4;14326:24;;14322:173;;;-1:-1:-1;;14391:35:0;;-1:-1:-1;14384:42:0;;14322:173;-1:-1:-1;;14462:33:0;;-1:-1:-1;14455:40:0;;12569:1327;12727:13;;12625:4;;;;12719:22;;6319:4;12768:26;;12764:1098;;;12819:1;12809:11;;12764:1098;;;6366:4;12850:25;;12846:1016;;;-1:-1:-1;;12900:30:0;;;-1:-1:-1;12846:1016:0;;;6413:4;12952:24;;12948:914;;;13047:4;13040:5;13036:16;13127:1;13119:6;13115:14;13105:24;;13285:7;13281:2;13277:16;13272:3;13268:26;13259:6;13253:13;13249:46;13383:1;13374:7;13370:15;13361:7;13357:29;13346:40;;13002:399;;;;;6460:4;13433:23;;13429:433;;;-1:-1:-1;;13483:28:0;;;-1:-1:-1;13429:433:0;;;13610:4;13603:5;13599:16;13655:1;13647:6;13643:14;13633:24;;13728:7;13724:2;13720:16;13715:3;13711:26;13702:6;13696:13;13692:46;13833:1;13824:7;13820:15;13811:7;13807:29;13796:40;;13565:286;;;-1:-1:-1;13881:7:0;12569:1327;-1:-1:-1;;12569:1327:0:o;115649:31280::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;115649:31280:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;115649:31280:0;;;-1:-1:-1;115649:31280:0;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;

bzzr://81bdbb6625c95c8457b75a818e9f1758f542b82fb50c67c02840b9362f0bc3cd