Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-03-26
*/

// 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() {
        _assertGovernance();
        _;
    }

    function _assertGovernance() private view {
        require(
            msg.sender == address(governance),
            "Only governance contract is authorized"
        );
    }
}

// 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: 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/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/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 tr vbmansfer 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/ERC20NonTradable.sol

pragma solidity ^0.5.2;


contract ERC20NonTradable is ERC20 {
    function _approve(
        address owner,
        address spender,
        uint256 value
    ) internal {
        revert("disabled");
    }
}

// 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: 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);
    }

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

// 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/EventsHub.sol

pragma solidity ^0.5.2;



contract IStakeManagerEventsHub {
    struct Validator {
        uint256 amount;
        uint256 reward;
        uint256 activationEpoch;
        uint256 deactivationEpoch;
        uint256 jailTime;
        address signer;
        address contractAddress;
    }

    mapping(uint256 => Validator) public validators;
}

contract EventsHub is Initializable {
    Registry public registry;

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

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

    function initialize(Registry _registry) external initializer {
        registry = _registry;
    }

    event ShareBurnedWithId(
        uint256 indexed validatorId,
        address indexed user,
        uint256 indexed amount,
        uint256 tokens,
        uint256 nonce
    );

    function logShareBurnedWithId(
        uint256 validatorId,
        address user,
        uint256 amount,
        uint256 tokens,
        uint256 nonce
    ) public onlyValidatorContract(validatorId) {
        emit ShareBurnedWithId(validatorId, user, amount, tokens, nonce);
    }

    event DelegatorUnstakeWithId(
        uint256 indexed validatorId,
        address indexed user,
        uint256 amount,
        uint256 nonce
    );

    function logDelegatorUnstakedWithId(
        uint256 validatorId,
        address user,
        uint256 amount,
        uint256 nonce
    ) public onlyValidatorContract(validatorId) {
        emit DelegatorUnstakeWithId(validatorId, user, amount, nonce);
    }

    event RewardParams(
        uint256 rewardDecreasePerCheckpoint,
        uint256 maxRewardedCheckpoints,
        uint256 checkpointRewardDelta
    );

    function logRewardParams(
        uint256 rewardDecreasePerCheckpoint,
        uint256 maxRewardedCheckpoints,
        uint256 checkpointRewardDelta
    ) public onlyStakeManager {
        emit RewardParams(rewardDecreasePerCheckpoint, maxRewardedCheckpoints, checkpointRewardDelta);
    }

    event UpdateCommissionRate(
        uint256 indexed validatorId,
        uint256 indexed newCommissionRate,
        uint256 indexed oldCommissionRate
    );

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

// 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/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/staking/stakeManager/IStakeManager.sol

pragma solidity 0.5.17;

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 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,
        uint[3][] calldata sigs
    ) external returns (uint256);

    function updateValidatorState(uint256 validatorId, int256 amount) public;

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

    function slash(bytes calldata slashingInfoList) external returns (uint256);

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

    function epoch() public view returns (uint256);

    function getRegistry() public view returns (address);

    function withdrawalDelay() public view returns (uint256);

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

    function decreaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) public;

    function withdrawDelegatorsReward(uint256 validatorId) public returns(uint256);

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

    function dethroneAndStake(
        address auctionUser,
        uint256 heimdallFee,
        uint256 validatorId,
        uint256 auctionAmount,
        bool acceptDelegation,
        bytes calldata signerPubkey
    ) external;
}

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

pragma solidity 0.5.17;

// note this contract interface is only for stakeManager use
contract IValidatorShare {
    function withdrawRewards() public;

    function unstakeClaimTokens() public;

    function getLiquidRewards(address user) public view returns (uint256);
    
    function owner() public view returns (address);

    function restake() public returns(uint256, uint256);

    function unlock() external;

    function lock() external;

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

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

    function updateDelegation(bool delegation) external;

    function migrateOut(address user, uint256 amount) external;

    function migrateIn(address user, uint256 amount) external;
}

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

pragma solidity 0.5.17;










contract ValidatorShare is IValidatorShare, ERC20NonTradable, OwnableLockable, Initializable {
    struct DelegatorUnbond {
        uint256 shares;
        uint256 withdrawEpoch;
    }

    uint256 constant EXCHANGE_RATE_PRECISION = 100;
    // maximum matic possible, even if rate will be 1 and all matic will be staken in one go, it will result in 10 ^ 58 shares
    uint256 constant EXCHANGE_RATE_HIGH_PRECISION = 10**29;
    uint256 constant MAX_COMMISION_RATE = 100;
    uint256 constant REWARD_PRECISION = 10**25;

    StakingInfo public stakingLogger;
    IStakeManager public stakeManager;
    uint256 public validatorId;
    uint256 public validatorRewards_deprecated;
    uint256 public commissionRate_deprecated;
    uint256 public lastCommissionUpdate_deprecated;
    uint256 public minAmount;

    uint256 public totalStake_deprecated;
    uint256 public rewardPerShare;
    uint256 public activeAmount;

    bool public delegation;

    uint256 public withdrawPool;
    uint256 public withdrawShares;

    mapping(address => uint256) amountStaked_deprecated; // deprecated, keep for foundation delegators
    mapping(address => DelegatorUnbond) public unbonds;
    mapping(address => uint256) public initalRewardPerShare;

    mapping(address => uint256) public unbondNonces;
    mapping(address => mapping(uint256 => DelegatorUnbond)) public unbonds_new;

    EventsHub public eventsHub;

    // 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);
        _getOrCacheEventsHub();

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

    /**
        Public View Methods
    */

    function exchangeRate() public view returns (uint256) {
        uint256 totalShares = totalSupply();
        uint256 precision = _getRatePrecision();
        return totalShares == 0 ? precision : stakeManager.delegatedAmount(validatorId).mul(precision).div(totalShares);
    }

    function getTotalStake(address user) public view returns (uint256, uint256) {
        uint256 shares = balanceOf(user);
        uint256 rate = exchangeRate();
        if (shares == 0) {
            return (0, rate);
        }

        return (rate.mul(shares).div(_getRatePrecision()), rate);
    }

    function withdrawExchangeRate() public view returns (uint256) {
        uint256 precision = _getRatePrecision();
        if (validatorId < 8) {
            // fix of potentially broken withdrawals for future unbonding
            // foundation validators have no slashing enabled and thus we can return default exchange rate
            // because without slashing rate will stay constant
            return precision;
        }

        uint256 _withdrawShares = withdrawShares;
        return _withdrawShares == 0 ? precision : withdrawPool.mul(precision).div(_withdrawShares);
    }

    function getLiquidRewards(address user) public view returns (uint256) {
        return _calculateReward(user, getRewardPerShare());
    }

    function getRewardPerShare() public view returns (uint256) {
        return _calculateRewardPerShareWithRewards(stakeManager.delegatorsReward(validatorId));
    }

    /**
        Public Methods
     */

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

    function restake() public returns(uint256, uint256) {
        address user = msg.sender;
        uint256 liquidReward = _withdrawReward(user);
        uint256 amountRestaked;

        require(liquidReward >= minAmount, "Too small rewards to restake");

        if (liquidReward != 0) {
            amountRestaked = _buyShares(liquidReward, 0, user);

            if (liquidReward > amountRestaked) {
                // return change to the user
                require(
                    stakeManager.transferFunds(validatorId, liquidReward - amountRestaked, user),
                    "Insufficent rewards"
                );
                stakingLogger.logDelegatorClaimRewards(validatorId, user, liquidReward - amountRestaked);
            }

            (uint256 totalStaked, ) = getTotalStake(user);
            stakingLogger.logDelegatorRestaked(validatorId, user, totalStaked);
        }
        
        return (amountRestaked, liquidReward);
    }

    function sellVoucher(uint256 claimAmount, uint256 maximumSharesToBurn) public {
        (uint256 shares, uint256 _withdrawPoolShare) = _sellVoucher(claimAmount, maximumSharesToBurn);

        DelegatorUnbond memory unbond = unbonds[msg.sender];
        unbond.shares = unbond.shares.add(_withdrawPoolShare);
        // refresh undond period
        unbond.withdrawEpoch = stakeManager.epoch();
        unbonds[msg.sender] = unbond;

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

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

    function migrateOut(address user, uint256 amount) external onlyOwner {
        _withdrawAndTransferReward(user);
        (uint256 totalStaked, uint256 rate) = getTotalStake(user);
        require(totalStaked >= amount, "Migrating too much");

        uint256 precision = _getRatePrecision();
        uint256 shares = amount.mul(precision).div(rate);
        _burn(user, shares);

        stakeManager.updateValidatorState(validatorId, -int256(amount));
        activeAmount = activeAmount.sub(amount);

        stakingLogger.logShareBurned(validatorId, user, amount, shares);
        stakingLogger.logStakeUpdate(validatorId);
        stakingLogger.logDelegatorUnstaked(validatorId, user, amount);
    }

    function migrateIn(address user, uint256 amount) external onlyOwner {
        _withdrawAndTransferReward(user);
        _buyShares(amount, 0, user);
    }

    function unstakeClaimTokens() public {
        DelegatorUnbond memory unbond = unbonds[msg.sender];
        uint256 amount = _unstakeClaimTokens(unbond);
        delete unbonds[msg.sender];
        stakingLogger.logDelegatorUnstaked(validatorId, msg.sender, amount);
    }

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

        // slash inactive pool
        uint256 stakeSlashed = _amountToSlash.sub(_amountToSlashWithdrawalPool);
        stakeManager.decreaseValidatorDelegatedAmount(validatorId, stakeSlashed);
        activeAmount = activeAmount.sub(stakeSlashed);

        withdrawPool = withdrawPool.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");
        }
    }

    /**
        New shares exit API
     */

    function sellVoucher_new(uint256 claimAmount, uint256 maximumSharesToBurn) public {
        (uint256 shares, uint256 _withdrawPoolShare) = _sellVoucher(claimAmount, maximumSharesToBurn);

        uint256 unbondNonce = unbondNonces[msg.sender].add(1);

        DelegatorUnbond memory unbond = DelegatorUnbond({
            shares: _withdrawPoolShare,
            withdrawEpoch: stakeManager.epoch()
        });
        unbonds_new[msg.sender][unbondNonce] = unbond;
        unbondNonces[msg.sender] = unbondNonce;

        _getOrCacheEventsHub().logShareBurnedWithId(validatorId, msg.sender, claimAmount, shares, unbondNonce);
        stakingLogger.logStakeUpdate(validatorId);
    }

    function unstakeClaimTokens_new(uint256 unbondNonce) public {
        DelegatorUnbond memory unbond = unbonds_new[msg.sender][unbondNonce];
        uint256 amount = _unstakeClaimTokens(unbond);
        delete unbonds_new[msg.sender][unbondNonce];
        _getOrCacheEventsHub().logDelegatorUnstakedWithId(validatorId, msg.sender, amount, unbondNonce);
    }

    /**
        Private Methods
     */

    function _getOrCacheEventsHub() private returns(EventsHub) {
        EventsHub _eventsHub = eventsHub;
        if (_eventsHub == EventsHub(0x0)) {
            _eventsHub = EventsHub(Registry(stakeManager.getRegistry()).contractMap(keccak256("eventsHub")));
            eventsHub = _eventsHub;
        }
        return _eventsHub;
    }

    function _sellVoucher(uint256 claimAmount, uint256 maximumSharesToBurn) private returns(uint256, uint256) {
        // first get how much staked in total and compare to target unstake amount
        (uint256 totalStaked, uint256 rate) = getTotalStake(msg.sender);
        require(totalStaked != 0 && totalStaked >= claimAmount, "Too much requested");

        // convert requested amount back to shares
        uint256 precision = _getRatePrecision();
        uint256 shares = claimAmount.mul(precision).div(rate);
        require(shares <= maximumSharesToBurn, "too much slippage");

        _withdrawAndTransferReward(msg.sender);

        _burn(msg.sender, shares);
        stakeManager.updateValidatorState(validatorId, -int256(claimAmount));
        activeAmount = activeAmount.sub(claimAmount);

        uint256 _withdrawPoolShare = claimAmount.mul(precision).div(withdrawExchangeRate());
        withdrawPool = withdrawPool.add(claimAmount);
        withdrawShares = withdrawShares.add(_withdrawPoolShare);

        return (shares, _withdrawPoolShare);
    }

    function _unstakeClaimTokens(DelegatorUnbond memory unbond) private returns(uint256) {
        uint256 shares = unbond.shares;
        require(
            unbond.withdrawEpoch.add(stakeManager.withdrawalDelay()) <= stakeManager.epoch() && shares > 0,
            "Incomplete withdrawal period"
        );

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

        require(stakeManager.transferFunds(validatorId, _amount, msg.sender), "Insufficent rewards");

        return _amount;
    }

    function _getRatePrecision() private view returns (uint256) {
        // if foundation validator, use old precision
        if (validatorId < 8) {
            return EXCHANGE_RATE_PRECISION;
        }

        return EXCHANGE_RATE_HIGH_PRECISION;
    }

    function _calculateRewardPerShareWithRewards(uint256 accumulatedReward) private view returns (uint256) {
        uint256 _rewardPerShare = rewardPerShare;
        if (accumulatedReward != 0) {
            uint256 totalShares = totalSupply();
            
            if (totalShares != 0) {
                _rewardPerShare = _rewardPerShare.add(accumulatedReward.mul(REWARD_PRECISION).div(totalShares));
            }
        }

        return _rewardPerShare;
    }

    function _calculateReward(address user, uint256 _rewardPerShare) private view returns (uint256) {
        uint256 shares = balanceOf(user);
        if (shares == 0) {
            return 0;
        }

        uint256 _initialRewardPerShare = initalRewardPerShare[user];

        if (_initialRewardPerShare == _rewardPerShare) {
            return 0;
        }

        return _rewardPerShare.sub(_initialRewardPerShare).mul(shares).div(REWARD_PRECISION);
    }

    function _withdrawReward(address user) private returns (uint256) {
        uint256 _rewardPerShare = _calculateRewardPerShareWithRewards(
            stakeManager.withdrawDelegatorsReward(validatorId)
        );
        uint256 liquidRewards = _calculateReward(user, _rewardPerShare);
        
        rewardPerShare = _rewardPerShare;
        initalRewardPerShare[user] = _rewardPerShare;
        return liquidRewards;
    }

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

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

        uint256 rate = exchangeRate();
        uint256 precision = _getRatePrecision();
        uint256 shares = _amount.mul(precision).div(rate);
        require(shares >= _minSharesToMint, "Too much slippage");
        require(unbonds[user].shares == 0, "Ongoing exit");

        _mint(user, shares);

        // clamp amount of tokens in case resulted shares requires less tokens than anticipated
        _amount = rate.mul(shares).div(precision);

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

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

        return _amount;
    }

    function _transfer(
        address from,
        address to,
        uint256 value
    ) internal {
        // get rewards for recipient 
        _withdrawAndTransferReward(to);
        // convert rewards to shares
        _withdrawAndTransferReward(from);
        // move shares to recipient
        super._transfer(from, to, value);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"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":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"constant":true,"inputs":[],"name":"activeAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint256","name":"_minSharesToMint","type":"uint256"}],"name":"buyVoucher","outputs":[{"internalType":"uint256","name":"amountToDeposit","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"commissionRate_deprecated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"delegation","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address payable","name":"destination","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"drain","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"eventsHub","outputs":[{"internalType":"contract EventsHub","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"exchangeRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getLiquidRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getRewardPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getTotalStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"initalRewardPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_validatorId","type":"uint256"},{"internalType":"address","name":"_stakingLogger","type":"address"},{"internalType":"address","name":"_stakeManager","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":[],"name":"lastCommissionUpdate_deprecated","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":false,"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"migrateIn","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"migrateOut","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"minAmount","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":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"restake","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"rewardPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"claimAmount","type":"uint256"},{"internalType":"uint256","name":"maximumSharesToBurn","type":"uint256"}],"name":"sellVoucher","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"claimAmount","type":"uint256"},{"internalType":"uint256","name":"maximumSharesToBurn","type":"uint256"}],"name":"sellVoucher_new","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"validatorStake","type":"uint256"},{"internalType":"uint256","name":"delegatedAmount","type":"uint256"},{"internalType":"uint256","name":"totalAmountToSlash","type":"uint256"}],"name":"slash","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"stakeManager","outputs":[{"internalType":"contract IStakeManager","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"stakingLogger","outputs":[{"internalType":"contract StakingInfo","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalStake_deprecated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","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":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"unbondNonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"unbonds","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"uint256","name":"withdrawEpoch","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"unbonds_new","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"uint256","name":"withdrawEpoch","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"unlock","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"unstakeClaimTokens","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"unbondNonce","type":"uint256"}],"name":"unstakeClaimTokens_new","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bool","name":"_delegation","type":"bool"}],"name":"updateDelegation","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"validatorId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"validatorRewards_deprecated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"withdrawExchangeRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"withdrawPool","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"withdrawRewards","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"withdrawShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]

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

43346:15196:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;43346:15196:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48359:615;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;48359:615:0;;;;;;;:::i;:::-;;12790:148;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;12790:148:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;10943:91;;;:::i;:::-;;;;;;;;;;;;;;;;46742:164;;;:::i;45677:306::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;45677:306:0;-1:-1:-1;;;;;45677:306:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;44091:46;;;:::i;13415:228::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;13415:228:0;;;;;;;;;;;;;;;;;:::i;44620:47::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44620:47:0;-1:-1:-1;;;;;44620:47:0;;:::i;14169:203::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;14169:203:0;;;;;;;;:::i;43995:42::-;;;:::i;44256:27::-;;;:::i;45389:280::-;;;:::i;43883:32::-;;;:::i;:::-;;;;-1:-1:-1;;;;;43883:32:0;;;;;;;;;;;;;;44220:29;;;:::i;47367:984::-;;;:::i;44323:27::-;;;:::i;43962:26::-;;;:::i;44177:36::-;;;:::i;44499:50::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44499:50:0;-1:-1:-1;;;;;44499:50:0;;:::i;46595:139::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;46595:139:0;-1:-1:-1;;;;;46595:139:0;;:::i;46958:401::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;46958:401:0;;;;;;;:::i;50343:1026::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;50343:1026:0;;;;;;;;;;;;:::i;49167:718::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;49167:718:0;;;;;;;;:::i;11253:106::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;11253:106:0;-1:-1:-1;;;;;11253:106:0;;:::i;19663:140::-;;;:::i;43922:33::-;;;:::i;44674:74::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;44674:74:0;;;;;;;;:::i;51377:106::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;51377:106:0;;;;:::i;44757:26::-;;;:::i;44044:40::-;;;:::i;44357:29::-;;;:::i;50058:277::-;;;:::i;18873:79::-;;;:::i;19208:92::-;;;:::i;44144:24::-;;;:::i;49893:157::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;49893:157:0;;;;;;;;:::i;14903:213::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;14903:213:0;;;;;;;;:::i;39865:68::-;;;:::i;12003:140::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;12003:140:0;;;;;;;;:::i;51491:328::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;51491:328:0;;;;;;;;;;;;;;;;;:::i;44900:433::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44900:433:0;;;-1:-1:-1;;;;;44900:433:0;;;;;;;;;;;;:::i;45991:596::-;;;:::i;48982:177::-;;;:::i;51876:696::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;51876:696:0;;;;;;;:::i;39322:18::-;;;:::i;11698:131::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;11698:131:0;;;;;;;;;;:::i;44292:22::-;;;:::i;44556:55::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44556:55:0;-1:-1:-1;;;;;44556:55:0;;:::i;52580:362::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;52580:362:0;;:::i;19980:109::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;19980:109:0;-1:-1:-1;;;;;19980:109:0;;:::i;39793:64::-;;;:::i;48359:615::-;48449:14;48465:26;48495:46;48508:11;48521:19;48495:12;:46::i;:::-;48448:93;;;;48554:29;;:::i;:::-;-1:-1:-1;48594:10:0;48586:19;;;;:7;:19;;;;;;;;;48554:51;;;;;;;;;;;;;;;;;;;;;;;;;48632:37;;48650:18;48632:37;:17;:37;:::i;:::-;48616:53;;48737:12;;:20;;;-1:-1:-1;;;48737:20:0;;;;-1:-1:-1;;;;;48737:12:0;;;;:18;;:20;;;;;;;;;;;;;;;:12;:20;;;5:2:-1;;;;30:1;27;20:12;5:2;48737:20:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;48737:20:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;48737:20:0;;48714;;;:43;;;48776:10;48768:19;;;;:7;:19;;;;;;;:28;;;;;;;;;;;;;;48830:13;;;48876:11;;48854:67;;-1:-1:-1;;;48854:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;48830:13:0;;;;;;48854:21;;:67;;;;;;;;;;48768:19;48830:13;48854:67;;;5:2:-1;;;;30:1;27;20:12;5:2;48854:67:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;48854:67:0;;;;48932:6;-1:-1:-1;;;;;48932:21:0;;48954:11;;48932:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;48932:34:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;48932:34:0;;;;48359:615;;;;;;:::o;12790:148::-;12855:4;12872:36;12881:10;12893:7;12902:5;12872:8;:36::i;:::-;-1:-1:-1;12926:4:0;12790:148;;;;;:::o;10943:91::-;11014:12;;10943:91;;:::o;46742:164::-;46855:12;;46885:11;;46855:42;;;-1:-1:-1;;;46855:42:0;;;;;;;;;;46792:7;;46819:79;;-1:-1:-1;;;;;46855:12:0;;;;:29;;:42;;;;;;;;;;;;;;;:12;:42;;;5:2:-1;;;;30:1;27;20:12;5:2;46855:42:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;46855:42:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;46855:42:0;46819:35;:79::i;:::-;46812:86;;46742:164;:::o;45677:306::-;45735:7;45744;45764:14;45781:15;45791:4;45781:9;:15::i;:::-;45764:32;;45807:12;45822:14;:12;:14::i;:::-;45807:29;-1:-1:-1;45851:11:0;45847:60;;45887:1;;-1:-1:-1;45890:4:0;-1:-1:-1;45879:16:0;;-1:-1:-1;45879:16:0;45847:60;45927:41;45948:19;:17;:19::i;:::-;45927:16;:4;45936:6;45927:16;:8;:16;:::i;:::-;:20;:41;:20;:41;:::i;:::-;45919:56;-1:-1:-1;45970:4:0;-1:-1:-1;;45677:306:0;;;;:::o;44091:46::-;;;;:::o;13415:228::-;13494:4;13511:26;13521:4;13527:2;13531:5;13511:9;:26::i;:::-;-1:-1:-1;;;;;13575:14:0;;;;;;:8;:14;;;;;;;;13563:10;13575:26;;;;;;;;;13548:65;;13557:4;;13575:37;;13606:5;13575:37;:30;:37;:::i;:::-;13548:8;:65::i;:::-;-1:-1:-1;13631:4:0;13415:228;;;;;;:::o;44620:47::-;;;;;;;;;;;;;:::o;14169:203::-;14275:10;14249:4;14296:20;;;:8;:20;;;;;;;;-1:-1:-1;;;;;14296:29:0;;;;;;;;;;14249:4;;14266:76;;14287:7;;14296:45;;14330:10;14296:45;:33;:45;:::i;43995:42::-;;;;:::o;44256:27::-;;;;:::o;45389:280::-;45434:7;45454:19;45476:13;:11;:13::i;:::-;45454:35;;45500:17;45520:19;:17;:19::i;:::-;45500:39;-1:-1:-1;45557:16:0;;:104;;45588:12;;45617:11;;45588:41;;;-1:-1:-1;;;45588:41:0;;;;;;;;;;:73;;45649:11;;45588:56;;45634:9;;-1:-1:-1;;;;;45588:12:0;;:28;;:41;;;;;;;;;;;;;;:12;:41;;;5:2:-1;;;;30:1;27;20:12;5:2;45588:41:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;45588:41:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;45588:41:0;;:56;:45;:56;:::i;:73::-;45557:104;;;45576:9;45557:104;45550:111;;;;45389:280;:::o;43883:32::-;;;-1:-1:-1;;;;;43883:32:0;;:::o;44220:29::-;;;;:::o;47367:984::-;47401:7;;47445:10;47401:7;47489:21;47445:10;47489:15;:21::i;:::-;47466:44;;47521:22;47580:9;;47564:12;:25;;47556:66;;;;;-1:-1:-1;;;47556:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;47639:17;;47635:651;;47690:33;47701:12;47715:1;47718:4;47690:10;:33::i;:::-;47673:50;;47759:14;47744:12;:29;47740:392;;;47870:12;;47897:11;;47870:76;;;-1:-1:-1;;;47870:76:0;;;;;;;;;47910:29;;;47870:76;;;;-1:-1:-1;;;;;47870:76:0;;;;;;;;;:12;;;:26;;:76;;;;;;;;;;;;;;;:12;;:76;;;5:2:-1;;;;30:1;27;20:12;5:2;47870:76:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;47870:76:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47870:76:0;47840:169;;;;;-1:-1:-1;;;47840:169:0;;;;;;;;;;;;-1:-1:-1;;;47840:169:0;;;;;;;;;;;;;;;48028:13;;;48067:11;;48028:88;;;-1:-1:-1;;;48028:88:0;;;;;;;;;-1:-1:-1;;;;;48028:88:0;;;;;;;48086:29;;;48028:88;;;;;;:13;;;:38;;:88;;;;;:13;;:88;;;;;;;:13;;:88;;;5:2:-1;;;;30:1;27;20:12;5:2;48028:88:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;48028:88:0;;;;47740:392;48149:19;48174;48188:4;48174:13;:19::i;:::-;-1:-1:-1;48208:13:0;;;48243:11;;48208:66;;;-1:-1:-1;;;48208:66:0;;;;;;;;;-1:-1:-1;;;;;48208:66:0;;;;;;;;;;;;;;;48148:45;;-1:-1:-1;48208:13:0;;:34;;:66;;;;;:13;;:66;;;;;;;;:13;;:66;;;5:2:-1;;;;30:1;27;20:12;5:2;48208:66:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;48208:66:0;;;;47635:651;;48314:14;-1:-1:-1;48330:12:0;-1:-1:-1;;47367:984:0;;:::o;44323:27::-;;;;:::o;43962:26::-;;;;:::o;44177:36::-;;;;:::o;44499:50::-;;;;;;;;;;;;;;;;;;;:::o;46595:139::-;46656:7;46683:43;46700:4;46706:19;:17;:19::i;:::-;46683:16;:43::i;46958:401::-;47036:23;47072:38;47099:10;47072:26;:38::i;:::-;;47149:49;47160:7;47169:16;47187:10;47149;:49::i;:::-;47217:12;;47248:11;;47217:72;;;-1:-1:-1;;;47217:72:0;;;;;;;;;;;;;;;47278:10;47217:72;;;;;47131:67;;-1:-1:-1;;;;;;47217:12:0;;;;:30;;:72;;;;;;;;;;;;;;;:12;;:72;;;5:2:-1;;;;30:1;27;20:12;5:2;47217:72:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;47217:72:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47217:72:0;47209:99;;;;;-1:-1:-1;;;47209:99:0;;;;;;;;;;;;-1:-1:-1;;;47209:99:0;;;;;;;;;;;;;;50343:1026;50497:7;19085:9;:7;:9::i;:::-;19077:18;;;;;;50541:12;;50517:21;50591:34;:15;50541:12;50591:34;:19;:34;:::i;:::-;50564:61;-1:-1:-1;50640:21:0;50636:62;;50685:1;50678:8;;;;;;50636:62;50788:22;50813:82;50858:36;:14;50877:16;50858:36;:18;:36;:::i;:::-;50813:40;:16;50834:18;50813:40;:20;:40;:::i;:82::-;50788:107;-1:-1:-1;50906:36:0;50945:55;50983:16;50945:33;:13;50788:107;50945:33;:17;:33;:::i;:55::-;50906:94;-1:-1:-1;51045:20:0;51068:48;:14;50906:94;51068:48;:18;:48;:::i;:::-;51127:12;;51173:11;;51127:72;;;-1:-1:-1;;;51127:72:0;;;;;;;;;;;;;;;;51045:71;;-1:-1:-1;;;;;;51127:12:0;;;;:45;;:72;;;;;:12;;:72;;;;;;;;:12;;:72;;;5:2:-1;;;;30:1;27;20:12;5:2;51127:72:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;51225:12:0;;:30;;-1:-1:-1;51225:12:0;-1:-1:-1;51242:12:0;51225:30;:16;:30;:::i;:::-;51210:12;:45;51283:12;;:46;;51300:28;51283:46;:16;:46;:::i;:::-;51268:12;:61;-1:-1:-1;51347:14:0;;50343:1026;-1:-1:-1;;;;;;;50343:1026:0:o;49167:718::-;19085:9;:7;:9::i;:::-;19077:18;;;;;;49247:32;49274:4;49247:26;:32::i;:::-;;49291:19;49312:12;49328:19;49342:4;49328:13;:19::i;:::-;49290:57;;;;49381:6;49366:11;:21;;49358:52;;;;;-1:-1:-1;;;49358:52:0;;;;;;;;;;;;-1:-1:-1;;;49358:52:0;;;;;;;;;;;;;;;49423:17;49443:19;:17;:19::i;:::-;49423:39;-1:-1:-1;49473:14:0;49490:31;49516:4;49490:21;:6;49423:39;49490:21;:10;:21;:::i;:31::-;49473:48;;49532:19;49538:4;49544:6;49532:5;:19::i;:::-;49564:12;;49598:11;;49564:63;;;-1:-1:-1;;;49564:63:0;;;;;;;;;:12;49611:15;;;49564:63;;;;;;-1:-1:-1;;;;;49564:12:0;;;;:33;;:63;;;;;:12;:63;;;;;;:12;;:63;;;5:2:-1;;;;30:1;27;20:12;5:2;49564:63:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;49653:12:0;;:24;;-1:-1:-1;49653:12:0;-1:-1:-1;49670:6:0;49653:24;:16;:24;:::i;:::-;49638:12;:39;49690:13;;;49719:11;;49690:63;;;-1:-1:-1;;;49690:63:0;;;;;;;;;-1:-1:-1;;;;;49690:63:0;;;;;;;;;;;;;;;;;;;;;:13;;;:28;;:63;;;;;:13;;:63;;;;;;;:13;;:63;;;5:2:-1;;;;30:1;27;20:12;5:2;49690:63:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;49764:13:0;;;49793:11;;49764:41;;;-1:-1:-1;;;49764:41:0;;;;;;;;;;-1:-1:-1;;;;;49764:13:0;;;;-1:-1:-1;49764:28:0;;-1:-1:-1;49764:41:0;;;;;:13;;:41;;;;;;;:13;;:41;;;5:2:-1;;;;30:1;27;20:12;5:2;49764:41:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;49816:13:0;;;49851:11;;49816:61;;;-1:-1:-1;;;49816:61:0;;;;;;;;;-1:-1:-1;;;;;49816:61:0;;;;;;;;;;;;;;;:13;;;-1:-1:-1;49816:34:0;;-1:-1:-1;49816:61:0;;;;;:13;;:61;;;;;;;:13;;:61;;;5:2:-1;;;;30:1;27;20:12;11253:106:0;-1:-1:-1;;;;;11335:16:0;11308:7;11335:16;;;;;;;;;;;;11253:106::o;19663:140::-;19085:9;:7;:9::i;:::-;19077:18;;;;;;19746:6;;19725:40;;19762:1;;19746:6;;;-1:-1:-1;;;;;19746:6:0;;19725:40;;19762:1;;19725:40;19776:6;:19;;-1:-1:-1;;;;;;19776:19:0;;;19663:140::o;43922:33::-;;;-1:-1:-1;;;;;43922:33:0;;:::o;44674:74::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;51377:106::-;19085:9;:7;:9::i;:::-;19077:18;;;;;;51451:10;:24;;-1:-1:-1;;51451:24:0;;;;;;;;;;51377:106::o;44757:26::-;;;-1:-1:-1;;;;;44757:26:0;;:::o;44044:40::-;;;;:::o;44357:29::-;;;;:::o;50058:277::-;50106:29;;:::i;:::-;-1:-1:-1;50146:10:0;50138:19;;;;:7;:19;;;;;;;;50106:51;;;;;;;;;;;;;;;;;;;;;;;50185:27;50106:51;50185:19;:27::i;:::-;50238:10;50230:19;;;;:7;:19;;;;;;50223:26;;;;;;;;50260:13;;;50295:11;;50260:67;;-1:-1:-1;;;50260:67:0;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;50260:13:0;;;;:34;;:67;;;;;50230:19;50260:67;;;;;;50230:19;50260:13;:67;;;5:2:-1;;;;30:1;27;20:12;5:2;50260:67:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;50260:67:0;;;;50058:277;;:::o;18873:79::-;18938:6;;;;;-1:-1:-1;;;;;18938:6:0;;18873:79::o;19208:92::-;19286:6;;;;;-1:-1:-1;;;;;19286:6:0;19272:10;:20;;19208:92::o;44144:24::-;;;;:::o;49893:157::-;19085:9;:7;:9::i;:::-;19077:18;;;;;;49972:32;49999:4;49972:26;:32::i;:::-;;50015:27;50026:6;50034:1;50037:4;50015:10;:27::i;:::-;;49893:157;;:::o;14903:213::-;15014:10;14988:4;15035:20;;;:8;:20;;;;;;;;-1:-1:-1;;;;;15035:29:0;;;;;;;;;;14988:4;;15005:81;;15026:7;;15035:50;;15069:15;15035:50;:33;:50;:::i;39865:68::-;19085:9;:7;:9::i;:::-;19077:18;;;;;;39911:14;:12;:14::i;:::-;39865:68::o;12003:140::-;12064:4;12081:32;12091:10;12103:2;12107:5;12081:9;:32::i;51491:328::-;19085:9;:7;:9::i;:::-;19077:18;;;;;;-1:-1:-1;;;;;51634:21:0;;51630:182;;51672:28;;-1:-1:-1;;;;;51672:20:0;;;:28;;;;;51693:6;;51672:28;;;;51693:6;51672:20;:28;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;51672:28:0;51630:182;;;51747:5;-1:-1:-1;;;;;51741:21:0;;51763:11;51776:6;51741:42;;;;;;;;;;;;;-1:-1:-1;;;;;51741:42:0;-1:-1:-1;;;;;51741:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51741:42:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;51741:42:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;51741:42:0;51733:67;;;;;-1:-1:-1;;;51733:67:0;;;;;;;;;;;;-1:-1:-1;;;51733:67:0;;;;;;;;;;;;;;44900:433;36215:6;;-1:-1:-1;;;36215:6:0;;;;36214:7;36206:34;;;;;-1:-1:-1;;;36206:34:0;;;;;;;;;;;;-1:-1:-1;;;36206:34:0;;;;;;;;;;;;;;;36251:6;:13;;-1:-1:-1;;;;36251:13:0;-1:-1:-1;;;36251:13:0;;;45055:11;:26;;;45092:13;:43;;-1:-1:-1;;;;;45092:43:0;;;-1:-1:-1;;;;;;45092:43:0;;;;;;;45146:12;:43;;;;;;;;;;;;;;;45200:33;45175:13;45200:18;:33::i;:::-;45244:22;:20;:22::i;:::-;-1:-1:-1;;45291:6:0;45279:9;:18;-1:-1:-1;;45308:10:0;:17;;-1:-1:-1;;45308:17:0;45321:4;45308:17;;;44900:433::o;45991:596::-;46044:7;46064:17;46084:19;:17;:19::i;:::-;46064:39;;46132:1;46118:11;;:15;46114:312;;;46405:9;-1:-1:-1;46398:16:0;;46114:312;46464:14;;46496:20;;:83;;46531:48;46563:15;46531:27;46548:9;46531:12;;:16;;:27;;;;:::i;46496:83::-;-1:-1:-1;46519:9:0;45991:596;-1:-1:-1;45991:596:0:o;48982:177::-;49027:15;49045:38;49072:10;49045:26;:38::i;:::-;49027:56;;49113:9;;49102:7;:20;;49094:57;;;;;-1:-1:-1;;;49094:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;48982:177;:::o;51876:696::-;51970:14;51986:26;52016:46;52029:11;52042:19;52016:12;:46::i;:::-;52110:10;52075:19;52097:24;;;:12;:24;;;;;;51969:93;;-1:-1:-1;51969:93:0;;-1:-1:-1;52075:19:0;52097:31;;52126:1;52097:31;:28;:31;:::i;:::-;52075:53;;52141:29;;:::i;:::-;52173:119;;;;;;;;52212:18;52173:119;;;;52260:12;;;;;;;;;-1:-1:-1;;;;;52260:12:0;-1:-1:-1;;;;;52260:18:0;;:20;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;52260:20:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;52260:20:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;52260:20:0;52173:119;;52315:10;52303:23;;;;:11;52260:20;52303:23;;;;;;;:36;;;;;;;;:45;;;;;;;;;;;;;52359:24;;;:12;:24;;;:38;;;52141:151;-1:-1:-1;52410:22:0;:20;:22::i;:::-;52454:11;;52410:102;;;-1:-1:-1;;;52410:102:0;;;;;;;;;52467:10;52410:102;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;52410:43:0;;;;;;;:102;;;;;-1:-1:-1;;52410:102:0;;;;;;;;-1:-1:-1;52410:43:0;:102;;;5:2:-1;;;;30:1;27;20:12;5:2;52410:102:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;52523:13:0;;;52552:11;;52523:41;;;-1:-1:-1;;;52523:41:0;;;;;;;;;;-1:-1:-1;;;;;52523:13:0;;;;-1:-1:-1;52523:28:0;;-1:-1:-1;52523:41:0;;;;;:13;;:41;;;;;;;:13;;:41;;;5:2:-1;;;;30:1;27;20:12;39322:18:0;;;;;;:::o;11698:131::-;-1:-1:-1;;;;;11797:15:0;;;11770:7;11797:15;;;:8;:15;;;;;;;;:24;;;;;;;;;;;;;11698:131::o;44292:22::-;;;;;;:::o;44556:55::-;;;;;;;;;;;;;:::o;52580:362::-;52651:29;;:::i;:::-;-1:-1:-1;52695:10:0;52683:23;;;;:11;:23;;;;;;;;:36;;;;;;;;52651:68;;;;;;;;;;;;;;;;;;;;;;;52747:27;52651:68;52747:19;:27::i;:::-;52804:10;52792:23;;;;:11;:23;;;;;;;;:36;;;;;;;;52785:43;;;;;;52730:44;-1:-1:-1;52839:22:0;:20;:22::i;:::-;52889:11;;52839:95;;;-1:-1:-1;;;52839:95:0;;;;;;;;;52902:10;52839:95;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;52839:49:0;;;;;;;:95;;;;;-1:-1:-1;;52839:95:0;;;;;;;;-1:-1:-1;52839:49:0;:95;;;5:2:-1;;;;30:1;27;20:12;5:2;52839:95:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;52839:95:0;;;;52580:362;;;:::o;19980:109::-;19085:9;:7;:9::i;:::-;19077:18;;;;;;20053:28;20072:8;20053:18;:28::i;39793:64::-;19085:9;:7;:9::i;:::-;19077:18;;;;;;39837:12;:10;:12::i;53345:1086::-;53433:7;53442;53547:19;53568:12;53584:25;53598:10;53584:13;:25::i;:::-;53546:63;;;;53628:11;53643:1;53628:16;;:46;;;;;53663:11;53648;:26;;53628:46;53620:77;;;;;-1:-1:-1;;;53620:77:0;;;;;;;;;;;;-1:-1:-1;;;53620:77:0;;;;;;;;;;;;;;;53762:17;53782:19;:17;:19::i;:::-;53762:39;-1:-1:-1;53812:14:0;53829:36;53860:4;53829:26;:11;53762:39;53829:26;:15;:26;:::i;:36::-;53812:53;;53894:19;53884:6;:29;;53876:59;;;;;-1:-1:-1;;;53876:59:0;;;;;;;;;;;;-1:-1:-1;;;53876:59:0;;;;;;;;;;;;;;;53948:38;53975:10;53948:26;:38::i;:::-;;53999:25;54005:10;54017:6;53999:5;:25::i;:::-;54035:12;;54069:11;;54035:68;;;-1:-1:-1;;;54035:68:0;;;;;;;;;:12;54082:20;;;54035:68;;;;;;-1:-1:-1;;;;;54035:12:0;;;;:33;;:68;;;;;:12;:68;;;;;;:12;;:68;;;5:2:-1;;;;30:1;27;20:12;5:2;54035:68:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;54129:12:0;;:29;;-1:-1:-1;54129:12:0;-1:-1:-1;54146:11:0;54129:29;:16;:29;:::i;:::-;54114:12;:44;54171:26;54200:54;54231:22;:20;:22::i;:::-;54200:26;:11;54216:9;54200:26;:15;:26;:::i;:54::-;54280:12;;54171:83;;-1:-1:-1;54280:29:0;;54297:11;54280:29;:16;:29;:::i;:::-;54265:12;:44;54337:14;;:38;;54356:18;54337:38;:18;:38;:::i;:::-;54320:14;:55;54396:6;;;;-1:-1:-1;53345:1086:0;-1:-1:-1;;;;;;53345:1086:0:o;9547:150::-;9605:7;9637:5;;;9661:6;;;;9653:15;;;;;17972:145;18091:18;;;-1:-1:-1;;;18091:18:0;;;;;;;;;;;;-1:-1:-1;;;18091:18:0;;;;;;;;;;;;;;55358:477;55498:14;;55452:7;;55527:22;;55523:270;;55566:19;55588:13;:11;:13::i;:::-;55566:35;-1:-1:-1;55634:16:0;;55630:152;;55689:77;55709:56;55753:11;55709:39;:17;43868:6;55709:39;:21;:39;:::i;:56::-;55689:15;;:77;:19;:77;:::i;:::-;55671:95;;55630:152;55523:270;55812:15;55358:477;-1:-1:-1;;55358:477:0:o;55091:259::-;55142:7;55235:1;55221:11;;:15;55217:78;;;-1:-1:-1;43585:3:0;55253:30;;55217:78;-1:-1:-1;43771:6:0;55091:259;:::o;8300:433::-;8358:7;8602:6;8598:47;;-1:-1:-1;8632:1:0;8625:8;;8598:47;8669:5;;;8673:1;8669;:5;:1;8693:5;;;;;:10;8685:19;;;;;8868:303;8926:7;9025:1;9021;:5;9013:14;;;;;;9038:9;9054:1;9050;:5;;;;;;;8868:303;-1:-1:-1;;;;8868:303:0:o;58187:352::-;58340:30;58367:2;58340:26;:30::i;:::-;;58419:32;58446:4;58419:26;:32::i;:::-;;58499;58515:4;58521:2;58525:5;58499:15;:32::i;9309:150::-;9367:7;9400:1;9395;:6;;9387:15;;;;;;-1:-1:-1;9425:5:0;;;9309:150::o;56323:434::-;56379:7;56399:23;56425:111;56475:12;;;;;;;;;-1:-1:-1;;;;;56475:12:0;-1:-1:-1;;;;;56475:37:0;;56513:11;;56475:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;56475:50:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;56425:111:0;56399:137;;56547:21;56571:39;56588:4;56594:15;56571:16;:39::i;:::-;56631:14;:32;;;-1:-1:-1;;;;;56674:26:0;;;;;;:20;:26;;;;;:44;;;;-1:-1:-1;56547:63:0;-1:-1:-1;56323:434:0;;;:::o;57184:995::-;57329:7;39388:17;:15;:17::i;:::-;57357:10;;;;57349:45;;;;;-1:-1:-1;;;57349:45:0;;;;;;;;;;;;-1:-1:-1;;;57349:45:0;;;;;;;;;;;;;;;57407:12;57422:14;:12;:14::i;:::-;57407:29;;57447:17;57467:19;:17;:19::i;:::-;57447:39;-1:-1:-1;57497:14:0;57514:32;57541:4;57514:22;:7;57447:39;57514:22;:11;:22;:::i;:32::-;57497:49;;57575:16;57565:6;:26;;57557:56;;;;;-1:-1:-1;;;57557:56:0;;;;;;;;;;;;-1:-1:-1;;;57557:56:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;57632:13:0;;;;;;:7;:13;;;;;:20;:25;57624:50;;;;;-1:-1:-1;;;57624:50:0;;;;;;;;;;;;-1:-1:-1;;;57624:50:0;;;;;;;;;;;;;;;57687:19;57693:4;57699:6;57687:5;:19::i;:::-;57826:31;57847:9;57826:16;:4;57835:6;57826:16;:8;:16;:::i;:31::-;57870:12;;57904:11;;57870:63;;;-1:-1:-1;;;57870:63:0;;;;;;;;;;;;;;;;57816:41;;-1:-1:-1;;;;;;57870:12:0;;;;:33;;:63;;;;;:12;;:63;;;;;;;;:12;;:63;;;5:2:-1;;;;30:1;27;20:12;5:2;57870:63:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;57959:12:0;;:25;;-1:-1:-1;57959:12:0;-1:-1:-1;57976:7:0;57959:25;:16;:25;:::i;:::-;57944:12;:40;58018:13;;;58064:11;;58042:57;;;-1:-1:-1;;;58042:57:0;;;;;;;;;-1:-1:-1;;;;;58042:57:0;;;;;;;;;;;;;;;;;;;;;58018:13;;;;;58042:21;;:57;;;;;57997:18;;58042:57;;;;;;;;57997:18;58018:13;58042:57;;;5:2:-1;;;;30:1;27;20:12;5:2;58042:57:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;58042:57:0;;;;58110:6;-1:-1:-1;;;;;58110:21:0;;58132:11;;58110:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;58110:34:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;58164:7:0;;57184:995;-1:-1:-1;;;;;;;;;;57184:995:0:o;55843:472::-;55930:7;55950:14;55967:15;55977:4;55967:9;:15::i;:::-;55950:32;-1:-1:-1;55997:11:0;55993:52;;56032:1;56025:8;;;;;55993:52;-1:-1:-1;;;;;56090:26:0;;56057:30;56090:26;;;:20;:26;;;;;;56133:41;;;56129:82;;;56198:1;56191:8;;;;;;56129:82;56230:77;43868:6;56230:55;56278:6;56230:43;:15;56250:22;56230:43;:19;:43;:::i;:::-;:47;:55;:47;:55;:::i;:77::-;56223:84;55843:472;-1:-1:-1;;;;;55843:472:0:o;56765:411::-;56832:7;56852:21;56876;56892:4;56876:15;:21::i;:::-;56852:45;-1:-1:-1;56912:18:0;;56908:230;;56955:12;;56982:11;;56955:60;;;-1:-1:-1;;;56955:60:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;56955:60:0;;;;;;;;;:12;;;:26;;:60;;;;;;;;;;;;;;;:12;;:60;;;5:2:-1;;;;30:1;27;20:12;5:2;56955:60:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;56955:60:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;56955:60:0;56947:92;;;;;-1:-1:-1;;;56947:92:0;;;;;;;;;;;;-1:-1:-1;;;56947:92:0;;;;;;;;;;;;;;;57054:13;;;57093:11;;57054:72;;;-1:-1:-1;;;57054:72:0;;;;;;;;;-1:-1:-1;;;;;57054:72:0;;;;;;;;;;;;;;;:13;;;:38;;:72;;;;;:13;;:72;;;;;;;:13;;:72;;;5:2:-1;;;;30:1;27;20:12;5:2;57054:72:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;57054:72:0;;;;57155:13;-1:-1:-1;56765:411:0;;;:::o;16460:269::-;-1:-1:-1;;;;;16535:21:0;;16527:30;;;;;;16585:12;;:23;;16602:5;16585:23;:16;:23;:::i;:::-;16570:12;:38;-1:-1:-1;;;;;16640:18:0;;:9;:18;;;;;;;;;;;:29;;16663:5;16640:29;:22;:29;:::i;:::-;-1:-1:-1;;;;;16619:18:0;;:9;:18;;;;;;;;;;;:50;;;;16685:36;;;;;;;16619:9;;16685:36;;;;;;;;;;;16460:269;;:::o;54439:644::-;54552:13;;54658:12;;:20;;;-1:-1:-1;;;54658:20:0;;;;54515:7;;54552:13;-1:-1:-1;;;;;54658:12:0;;:18;;:20;;;;;;;;;;;;;;:12;:20;;;5:2:-1;;;;30:1;27;20:12;5:2;54658:20:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;54658:20:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;54658:20:0;54623:12;;:30;;;-1:-1:-1;;;54623:30:0;;;;54598:56;;-1:-1:-1;;;;;54623:12:0;;:28;;:30;;;;;54658:20;;54623:30;;;;;;;:12;:30;;;5:2:-1;;;;30:1;27;20:12;5:2;54623:30:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;54623:30:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;54623:30:0;;54598:20;;;;:56;:24;:56;:::i;:::-;:80;;:94;;;;;54691:1;54682:6;:10;54598:94;54576:172;;;;;-1:-1:-1;;;54576:172:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;54761:15;54779:59;54818:19;:17;:19::i;:::-;54779:34;54806:6;54779:22;:20;:22::i;:59::-;54866:14;;54761:77;;-1:-1:-1;54866:26:0;;54885:6;54866:26;:18;:26;:::i;:::-;54849:14;:43;54918:12;;:25;;54935:7;54918:25;:16;:25;:::i;:::-;54903:12;:40;54964:12;;54991:11;;54964:60;;;-1:-1:-1;;;54964:60:0;;;;;;;;;;;;;;;55013:10;54964:60;;;;;-1:-1:-1;;;;;54964:12:0;;;;:26;;:60;;;;;;;;;;;;;;;:12;;:60;;;5:2:-1;;;;30:1;27;20:12;5:2;54964:60:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;54964:60:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;54964:60:0;54956:92;;;;;-1:-1:-1;;;54956:92:0;;;;;;;;;;;;-1:-1:-1;;;54956:92:0;;;;;;;;;;;;;;39589:58;39625:6;:14;;-1:-1:-1;;39625:14:0;;;39589:58::o;20239:187::-;-1:-1:-1;;;;;20313:22:0;;20305:31;;;;;;20373:6;;20352:38;;-1:-1:-1;;;;;20352:38:0;;;;20373:6;;;;;20352:38;;;;;20401:6;:17;;-1:-1:-1;;;;;20401:17:0;;;;;-1:-1:-1;;;;;;20401:17:0;;;;;;;;;20239:187::o;52995:342::-;53088:9;;53043;;-1:-1:-1;;;;;53088:9:0;53112:28;53108:194;;53189:12;;;;;;;;;-1:-1:-1;;;;;53189:12:0;-1:-1:-1;;;;;53189:24:0;;:26;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;53189:26:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;53189:26:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;53189:26:0;53229:22;;;-1:-1:-1;;;53229:22:0;;;;;;;;;;;;-1:-1:-1;;;53180:72:0;;;;;;;;-1:-1:-1;;;;;53180:48:0;;;;;;:72;;;;;53189:26;;53180:72;;;;;;;;:48;:72;;;5:2:-1;;;;30:1;27;20:12;5:2;53180:72:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;53180:72:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;53180:72:0;53268:9;:22;;-1:-1:-1;;;;;;53268:22:0;-1:-1:-1;;;;;53268:22:0;;;;;53180:72;-1:-1:-1;53319:10:0;-1:-1:-1;52995:342:0;:::o;39526:55::-;39560:6;:13;;-1:-1:-1;;39560:13:0;39569:4;39560:13;;;39526:55::o;15343:262::-;-1:-1:-1;;;;;15431:16:0;;15423:25;;;;;;-1:-1:-1;;;;;15479:15:0;;:9;:15;;;;;;;;;;;:26;;15499:5;15479:26;:19;:26;:::i;:::-;-1:-1:-1;;;;;15461:15:0;;;:9;:15;;;;;;;;;;;:44;;;;15532:13;;;;;;;:24;;15550:5;15532:24;:17;:24;:::i;:::-;-1:-1:-1;;;;;15516:13:0;;;:9;:13;;;;;;;;;;;;:40;;;;15572:25;;;;;;;15516:13;;15572:25;;;;;;;;;;;;;15343:262;;;:::o;39433:85::-;39493:6;;;;39492:7;39484:26;;;;;-1:-1:-1;;;39484:26:0;;;;;;;;;;;;-1:-1:-1;;;39484:26:0;;;;;;;;;;;;;;15957:269;-1:-1:-1;;;;;16032:21:0;;16024:30;;;;;;16082:12;;:23;;16099:5;16082:23;:16;:23;:::i;:::-;16067:12;:38;-1:-1:-1;;;;;16137:18:0;;:9;:18;;;;;;;;;;;:29;;16160:5;16137:29;:22;:29;:::i;:::-;-1:-1:-1;;;;;16116:18:0;;:9;:18;;;;;;;;;;;:50;;;;16182:36;;;;;;;16116:18;;:9;;16182:36;;;;;;;;;;15957:269;;:::o;43346:15196::-;;;;;;;;;;;;;;;;;;;:::o

bzzr://e0717f62363177110fcfd3ec1db08ba11d62877157d14e00a22e8a3237b30379