Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b, st ...
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(address ...
•    - function _verifyCallResult(bool succe ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function _callOptionalReturn(IERC20 t ...
• interface IERC165
•    - function supportsInterface(bytes4 int ...
•    - function supportsInterface(bytes4 int ...
• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
• interface IAccessControl
•    - function hasRole(bytes32 role, addres ...
•    - function getRoleAdmin(bytes32 role)
•    - function grantRole(bytes32 role, addr ...
•    - function revokeRole(bytes32 role, add ...
•    - function renounceRole(bytes32 role, a ...
•    - function supportsInterface(bytes4 int ...
•    - function hasRole(bytes32 role, addres ...
•    - function _checkRole(bytes32 role, add ...
•    - function getRoleAdmin(bytes32 role)
•    - function grantRole(bytes32 role, addr ...
•    - function revokeRole(bytes32 role, add ...
•    - function renounceRole(bytes32 role, a ...
•    - function _setupRole(bytes32 role, add ...
•    - function _setRoleAdmin(bytes32 role, ...
•    - function _grantRole(bytes32 role, add ...
•    - function _revokeRole(bytes32 role, ad ...
•  contract VestingMultiVault is Acce ...
•    - function issue(
•    - function revoke(
•    - function release(
•    - function releaseMultiple(
•    - function allocationCount(
•    - function releasableAmount(
•    - function totalReleasableAount(
•    - function vestedAmount(
•    - function totalVestedAount(
•    - function _releasableAmount(
•    - function _vestedAmount(
•  contract StakeRewarder is Ownable *
•    - function createPool(
•    - function updatePool(
•    - function setRewardPerBlock(
•    - function setVestingRules(
•    - function duration(
•    - function totalPendingRewards(
•    - function pendingRewards(
•    - function totalPower(
•    - function power(
•    - function pokePools()
•    - function pokePool(
•    - function claim(
•    - function claimMultiple(
•    - function deposit(
•    - function withdraw(
•    - function emergencyWithdraw(
•    - function emergencyReclaim(
•    - function poolLength()
•    - function _claim(
•    - function _safelyDistribute(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-06-29
*/

/**
 *Submitted for verification at Etherscan.io on 2021-06-28
*/

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: 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
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

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


pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // 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-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

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


pragma solidity ^0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

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


pragma solidity ^0.8.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

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


pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

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


pragma solidity ^0.8.0;



/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

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


pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

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


pragma solidity ^0.8.0;


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

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


pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant alphabet = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = alphabet[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

}

// File: openzeppelin-solidity/contracts/access/AccessControl.sol


pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    function hasRole(bytes32 role, address account) external view returns (bool);
    function getRoleAdmin(bytes32 role) external view returns (bytes32);
    function grantRole(bytes32 role, address account) external;
    function revokeRole(bytes32 role, address account) external;
    function renounceRole(bytes32 role, address account) external;
}

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping (address => bool) members;
        bytes32 adminRole;
    }

    mapping (bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role, _msgSender());
        _;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId
            || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/
     */
    function _checkRole(bytes32 role, address account) internal view {
        if(!hasRole(role, account)) {
            revert(string(abi.encodePacked(
                "AccessControl: account ",
                Strings.toHexString(uint160(account), 20),
                " is missing role ",
                Strings.toHexString(uint256(role), 32)
            )));
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);
        _roles[role].adminRole = adminRole;
    }

    function _grantRole(bytes32 role, address account) private {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    function _revokeRole(bytes32 role, address account) private {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

// File: contracts/VestingMultiVault.sol

pragma solidity ^0.8.0;





/**
 * @title VestingMultiVault
 * @dev A token vesting contract that will release tokens gradually like a
 * standard equity vesting schedule, with a cliff and vesting period but no
 * arbitrary restrictions on the frequency of claims. Optionally has an initial
 * tranche claimable immediately after the cliff expires (in addition to any
 * amounts that would have vested up to that point but didn't due to a cliff).
 */
contract VestingMultiVault is AccessControl {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    event Issued(
        address indexed beneficiary,
        uint256 indexed allocationId,
        uint256 amount,
        uint256 start,
        uint256 cliff,
        uint256 duration
    );

    event Released(
        address indexed beneficiary,
        uint256 indexed allocationId,
        uint256 amount,
        uint256 remaining
    );
    
    event Revoked(
        address indexed beneficiary,
        uint256 indexed allocationId,
        uint256 allocationAmount,
        uint256 revokedAmount
    );

    struct Allocation {
        uint256 start;
        uint256 cliff;
        uint256 duration;
        uint256 total;
        uint256 claimed;
        uint256 initial;
    }

    // The token being vested.
    IERC20 public immutable token;

    // The amount unclaimed for an address, whether or not vested.
    mapping(address => uint256) public pendingAmount;

    // The allocations assigned to an address.
    mapping(address => Allocation[]) public userAllocations;

    // The precomputed hash of the "ISSUER" role.
    bytes32 public constant ISSUER = keccak256("ISSUER");

    /**
     * @dev Creates a vesting contract that releases allocations of a token
     * over an arbitrary time period with support for tranches and cliffs.
     * @param _token The ERC-20 token to be vested
     */
    constructor(IERC20 _token) {
        token = _token;
        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _setupRole(ISSUER, msg.sender);
    }

    /**
     * @dev Creates a new allocation for a beneficiary. Tokens are released
     * linearly over time until a given number of seconds have passed since the
     * start of the vesting schedule. Callable only by issuers.
     * @param _beneficiary The address to which tokens will be released
     * @param _amount The amount of the allocation (in wei)
     * @param _startAt The unix timestamp at which the vesting may begin
     * @param _cliff The number of seconds after _startAt before which no vesting occurs
     * @param _duration The number of seconds after which the entire allocation is vested
     * @param _initialPct The percentage of the allocation initially available (integer, 0-100)
     */
    function issue(
        address _beneficiary,
        uint256 _amount,
        uint256 _startAt,
        uint256 _cliff,
        uint256 _duration,
        uint256 _initialPct
    ) public onlyRole(ISSUER) {
        require(token.allowance(msg.sender, address(this)) >= _amount, "Token allowance not sufficient");
        require(_beneficiary != address(0), "Cannot grant tokens to the zero address");
        require(_cliff <= _duration, "Cliff must not exceed duration");
        require(_initialPct <= 100, "Initial release percentage must be an integer 0 to 100 (inclusive)");

        // Pull the number of tokens required for the allocation.
        token.safeTransferFrom(msg.sender, address(this), _amount);

        // Increase the total pending for the address.
        pendingAmount[_beneficiary] = pendingAmount[_beneficiary].add(_amount);

        // Push the new allocation into the stack.
        userAllocations[_beneficiary].push(Allocation({
            claimed:    0,
            cliff:      _cliff,
            duration:   _duration,
            initial:    _amount.mul(_initialPct).div(100),
            start:      _startAt,
            total:      _amount
        }));
        
        emit Issued(
            _beneficiary,
            userAllocations[_beneficiary].length - 1,
            _amount,
            _startAt,
            _cliff,
            _duration
        );
    }
    
    /**
     * @dev Revokes an existing allocation. Any unclaimed tokens are recalled
     * and sent to the caller. Callable only be issuers.
     * @param _beneficiary The address whose allocation is to be revoked
     * @param _id The allocation ID to revoke
     */
    function revoke(
        address _beneficiary,
        uint256 _id
    ) public onlyRole(ISSUER) {
        Allocation storage allocation = userAllocations[_beneficiary][_id];
        
        // Calculate the remaining amount.
        uint256 total = allocation.total;
        uint256 remainder = total.sub(allocation.claimed);

        // Update the total pending for the address.
        pendingAmount[_beneficiary] = pendingAmount[_beneficiary].sub(remainder);

        // Update the allocation to be claimed in full.
        allocation.claimed = total;
        
        // Transfer the tokens vested 
        token.safeTransfer(msg.sender, remainder);
        emit Revoked(
            _beneficiary,
            _id,
            total,
            remainder
        );
    }

    /**
     * @dev Transfers vested tokens from an allocation to its beneficiary. Callable by anyone.
     * @param _beneficiary The address that has vested tokens
     * @param _id The vested allocation index
     */
    function release(
        address _beneficiary,
        uint256 _id
    ) public {
        Allocation storage allocation = userAllocations[_beneficiary][_id];

        // Calculate the releasable amount.
        uint256 amount = _releasableAmount(allocation);
        require(amount > 0, "Nothing to release");
        
        // Add the amount to the allocation's total claimed.
        allocation.claimed = allocation.claimed.add(amount);

        // Subtract the amount from the beneficiary's total pending.
        pendingAmount[_beneficiary] = pendingAmount[_beneficiary].sub(amount);

        // Transfer the tokens to the beneficiary.
        token.safeTransfer(_beneficiary, amount);

        emit Released(
            _beneficiary,
            _id,
            amount,
            allocation.total.sub(allocation.claimed)
        );
    }
    
    /**
     * @dev Transfers vested tokens from any number of allocations to their beneficiary. Callable by anyone. May be gas-intensive.
     * @param _beneficiary The address that has vested tokens
     * @param _ids The vested allocation indexes
     */
    function releaseMultiple(
        address _beneficiary,
        uint256[] calldata _ids
    ) external {
        for (uint256 i = 0; i < _ids.length; i++) {
            release(_beneficiary, _ids[i]);
        }
    }
    
    /**
     * @dev Gets the number of allocations issued for a given address.
     * @param _beneficiary The address to check for allocations
     */
    function allocationCount(
        address _beneficiary
    ) public view returns (uint256 count) {
        return userAllocations[_beneficiary].length;
    }
    
    /**
     * @dev Calculates the amount that has already vested but has not yet been released for a given address.
     * @param _beneficiary Address to check
     * @param _id The allocation index
     */
    function releasableAmount(
        address _beneficiary,
        uint256 _id
    ) public view returns (uint256 amount) {
        Allocation storage allocation = userAllocations[_beneficiary][_id];
        return _releasableAmount(allocation);
    }
    
    /**
     * @dev Gets the total releasable for a given address. Likely gas-intensive, not intended for contract use.
     * @param _beneficiary Address to check
     */
    function totalReleasableAount(
        address _beneficiary
    ) public view returns (uint256 amount) {
        for (uint256 i = 0; i < allocationCount(_beneficiary); i++) {
            amount = amount.add(releasableAmount(_beneficiary, i));
        }
        return amount;
    }
    
    /**
     * @dev Calculates the amount that has vested to date.
     * @param _beneficiary Address to check
     * @param _id The allocation index
     */
    function vestedAmount(
        address _beneficiary,
        uint256 _id
    ) public view returns (uint256) {
        Allocation storage allocation = userAllocations[_beneficiary][_id];
        return _vestedAmount(allocation);
    }
    
    /**
     * @dev Gets the total ever vested for a given address. Likely gas-intensive, not intended for contract use.
     * @param _beneficiary Address to check
     */
    function totalVestedAount(
        address _beneficiary
    ) public view returns (uint256 amount) {
        for (uint256 i = 0; i < allocationCount(_beneficiary); i++) {
            amount = amount.add(vestedAmount(_beneficiary, i));
        }
        return amount;
    }

    /**
     * @dev Calculates the amount that has already vested but hasn't been released yet.
     * @param allocation Allocation to calculate against
     */
    function _releasableAmount(
        Allocation storage allocation
    ) internal view returns (uint256) {
        return _vestedAmount(allocation).sub(allocation.claimed);
    }

    /**
     * @dev Calculates the amount that has already vested.
     * @param allocation Allocation to calculate against
     */
    function _vestedAmount(
        Allocation storage allocation
    ) internal view returns (uint256 amount) {
        if (block.timestamp < allocation.start.add(allocation.cliff)) {
            // Nothing is vested until after the start time + cliff length.
            amount = 0;
        } else if (block.timestamp >= allocation.start.add(allocation.duration)) {
            // The entire amount has vested if the entire duration has elapsed.
            amount = allocation.total;
        } else {
            // The initial tranche is available once the cliff expires, plus any portion of
            // tokens which have otherwise become vested as of the current block's timestamp.
            amount = allocation.initial.add(
                allocation.total
                    .sub(allocation.initial)
                    .sub(amount)
                    .mul(block.timestamp.sub(allocation.start))
                    .div(allocation.duration)
            );
        }
        
        return amount;
    }
}

// File: contracts/StakeRewarder.sol

pragma solidity ^0.8.5;

/**
 * @title StakeRewarder
 * @dev This contract distributes rewards to depositors of supported tokens.
 * It's based on Sushi's MasterChef v1, but notably only serves what's already
 * available: no new tokens can be created. It's just a restaurant, not a farm.
 */
contract StakeRewarder is Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;
    
    struct UserInfo {
        uint256 amount;     // Quantity of tokens the user has staked.
        uint256 rewardDebt; // Reward debt. See explanation below.
        // We do some fancy math here. Basically, any point in time, the
        // amount of rewards entitled to a user but is pending to be distributed is:
        //
        //   pendingReward = (stakedAmount * pool.accPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws tokens in a pool:
        //   1. The pool's `accPerShare` (and `lastRewardBlock`) gets updated.
        //   2. User's pending rewards are issued (greatly simplifies accounting).
        //   3. User's `amount` gets updated.
        //   4. User's `rewardDebt` gets updated.
    }
    
    struct PoolInfo {
        IERC20 token;            // Address of the token contract.
        uint256 weight;          // Weight points assigned to this pool.
        uint256 power;           // The multiplier for determining "staking power".
        uint256 total;           // Total number of tokens staked.
        uint256 accPerShare;     // Accumulated rewards per share (times 1e12).
        uint256 lastRewardBlock; // Last block where rewards were calculated.
    }
    
    // Distribution vault.
    VestingMultiVault public immutable vault;
    
    // Reward configuration.
    IERC20 public immutable rewardToken;
    uint256 public rewardPerBlock;
    uint256 public vestingCliff;
    uint256 public vestingDuration;
    
    // Housekeeping for each pool.
    PoolInfo[] public poolInfo;
    
    // Info of each user that stakes tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;
    
    // Underpaid rewards owed to a user.
    mapping(address => uint256) public underpayment;
    
    // The sum of weights across all staking tokens.
    uint256 public totalWeight = 0;
    
    // The block number when staking starts.
    uint256 public startBlock;
    
    event TokenAdded(address indexed token, uint256 weight, uint256 totalWeight);
    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event Claim(address indexed user, uint256 amount);
    event EmergencyReclaim(address indexed user, address token, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);

    /**
     * @dev Create a staking contract that rewards depositors using its own token balance
     * and optionally vests rewards over time.
     * @param _rewardToken The token to be distributed as rewards.
     * @param _rewardPerBlock The quantity of reward tokens accrued per block.
     * @param _startBlock The first block at which staking is allowed.
     * @param _vestingCliff The number of seconds until issued rewards begin vesting.
     * @param _vestingDuration The number of seconds after issuance until vesting is completed.
     * @param _vault The VestingMultiVault that is ultimately responsible for reward distribution.
     */
    constructor(
        IERC20 _rewardToken,
        uint256 _rewardPerBlock,
        uint256 _startBlock,
        uint256 _vestingCliff,
        uint256 _vestingDuration,
        VestingMultiVault _vault
    ) {
        // Set the initial reward config
        rewardPerBlock = _rewardPerBlock;
        startBlock = _startBlock;
        vestingCliff = _vestingCliff;
        vestingDuration = _vestingDuration;
        
        // Set the vault and reward token (immutable after creation)
        vault = _vault;
        rewardToken = _rewardToken;
        
        // Approve the vault to pull reward tokens
        _rewardToken.approve(address(_vault), 2**256 - 1);
    }

    /**
     * @dev Adds a new staking pool to the stack. Can only be called by the owner.
     * @param _token The token to be staked.
     * @param _weight The weight of this pool (used to determine proportion of rewards relative to the total weight).
     * @param _power The power factor of this pool (used as a multiple of tokens staked, e.g. for determining voting power).
     * @param _shouldUpdate Whether to update all pools first.
     */
    function createPool(
        IERC20 _token,
        uint256 _weight,
        uint256 _power,
        bool _shouldUpdate
    ) public onlyOwner {
        if (_shouldUpdate) {
            pokePools();
        }

        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalWeight = totalWeight.add(_weight);
        poolInfo.push(
            PoolInfo({
                token: _token,
                weight: _weight,
                power: _power,
                total: 0,
                accPerShare: 0,
                lastRewardBlock: lastRewardBlock
            })
        );
    }

    /**
     * @dev Update the given staking pool's weight and power. Can only be called by the owner.
     * @param _pid The pool identifier.
     * @param _weight The weight of this pool (used to determine proportion of rewards relative to the total weight).
     * @param _power The power of this pool's token (used as a multiplier of tokens staked, e.g. for voting).
     * @param _shouldUpdate Whether to update all pools first.
     */ 
    function updatePool(
        uint256 _pid,
        uint256 _weight,
        uint256 _power,
        bool _shouldUpdate
    ) public onlyOwner {
        if (_shouldUpdate) {
            pokePools();
        }
        
        totalWeight = totalWeight.sub(poolInfo[_pid].weight).add(
            _weight
        );

        poolInfo[_pid].weight = _weight;
        poolInfo[_pid].power = _power;
    }
    
    /**
     * @dev Update the reward per block. Can only be called by the owner.
     * @param _rewardPerBlock The total quantity to distribute per block.
     */
    function setRewardPerBlock(
        uint256 _rewardPerBlock
    ) public onlyOwner {
        rewardPerBlock = _rewardPerBlock;
    }
    
    /**
     * @dev Update the vesting rules for rewards. Can only be called by the owner.
     * @param _duration the number of seconds over which vesting occurs (see VestingMultiVault)
     * @param _cliff the number of seconds before any release occurs (see VestingMultiVault)
     */
    function setVestingRules(
        uint256 _duration,
        uint256 _cliff
    ) public onlyOwner {
        vestingDuration = _duration;
        vestingCliff = _cliff;
    }

    /**
     * @dev Calculate elapsed blocks between `_from` and `_to`.
     * @param _from The starting block.
     * @param _to The ending block.
     */
    function duration(
        uint256 _from,
        uint256 _to
    ) public pure returns (uint256) {
        return _to.sub(_from);
    }
    
    function totalPendingRewards(
        address _beneficiary
    ) public view returns (uint256 total) {
        for (uint256 pid = 0; pid < poolInfo.length; pid++) {
            total = total.add(pendingRewards(pid, _beneficiary));
        }

        return total;
    }

    /**
     * @dev View function to see pending rewards for an address. Likely gas intensive.
     * @param _pid The pool identifier.
     * @param _beneficiary The address to check.
     */
    function pendingRewards(
        uint256 _pid,
        address _beneficiary
    ) public view returns (uint256 amount) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_beneficiary];
        uint256 accPerShare = pool.accPerShare;
        uint256 tokenSupply = pool.total;
        
        if (block.number > pool.lastRewardBlock && tokenSupply != 0) {
            uint256 reward = duration(pool.lastRewardBlock, block.number)
                .mul(rewardPerBlock)
                .mul(pool.weight)
                .div(totalWeight);

            accPerShare = accPerShare.add(
                reward.mul(1e12).div(tokenSupply)
            );
        }

        return user.amount.mul(accPerShare).div(1e12).sub(user.rewardDebt);
    }

    /**
     * @dev Gets the sum of power for every pool. Likely gas intensive.
     * @param _beneficiary The address to check.
     */
    function totalPower(
        address _beneficiary
    ) public view returns (uint256 total) {
        for (uint256 pid = 0; pid < poolInfo.length; pid++) {
            total = total.add(power(pid, _beneficiary));
        }

        return total;
    }

    /**
     * @dev Gets power for a single pool.
     * @param _pid The pool identifier.
     * @param _beneficiary The address to check.
     */
    function power(
        uint256 _pid,
        address _beneficiary
    ) public view returns (uint256 amount) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_beneficiary];
        return pool.power.mul(user.amount);
    }

    /**
     * @dev Update all pools. Callable by anyone. Could be gas intensive.
     */
    function pokePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            pokePool(pid);
        }
    }

    /**
     * @dev Update rewards of the given pool to be up-to-date. Callable by anyone.
     * @param _pid The pool identifier.
     */
    function pokePool(
        uint256 _pid
    ) public {
        PoolInfo storage pool = poolInfo[_pid];

        if (block.number <= pool.lastRewardBlock) {
            return;
        }

        uint256 tokenSupply = pool.total;
        if (tokenSupply == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }

        uint256 reward = duration(pool.lastRewardBlock, block.number)
            .mul(rewardPerBlock)
            .mul(pool.weight)
            .div(totalWeight);

        pool.accPerShare = pool.accPerShare.add(
            reward.mul(1e12).div(tokenSupply)
        );

        pool.lastRewardBlock = block.number;
    }

    /**
     * @dev Claim rewards not yet distributed for an address. Callable by anyone.
     * @param _pid The pool identifier.
     * @param _beneficiary The address to claim for.
     */
    function claim(
        uint256 _pid,
        address _beneficiary
    ) public {
        // make sure the pool is up-to-date
        pokePool(_pid);

        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_beneficiary];

        _claim(pool, user, _beneficiary);
    }
    
    /**
     * @dev Claim rewards from multiple pools. Callable by anyone.
     * @param _pids An array of pool identifiers.
     * @param _beneficiary The address to claim for.
     */
    function claimMultiple(
        uint256[] calldata _pids,
        address _beneficiary
    ) external {
        for (uint256 i = 0; i < _pids.length; i++) {
            claim(_pids[i], _beneficiary);
        }
    }

    /**
     * @dev Stake tokens to earn a share of rewards.
     * @param _pid The pool identifier.
     * @param _amount The number of tokens to deposit.
     */
    function deposit(
        uint256 _pid,
        uint256 _amount
    ) public {
        require(_amount > 0, "deposit: only non-zero amounts allowed");
        
        // make sure the pool is up-to-date
        pokePool(_pid);

        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        
        // deliver any pending rewards
        _claim(pool, user, msg.sender);
        
        // pull in user's staked assets
        pool.token.safeTransferFrom(
            address(msg.sender),
            address(this),
            _amount
        );

        // update the pool's total deposit
        pool.total = pool.total.add(_amount);
        
        // update user's deposit and reward info
        user.amount = user.amount.add(_amount);
        user.rewardDebt = user.amount.mul(pool.accPerShare).div(1e12);
        
        emit Deposit(msg.sender, _pid, _amount);
    }

    /**
     * @dev Withdraw staked tokens and any pending rewards.
     */
    function withdraw(
        uint256 _pid,
        uint256 _amount
    ) public {
        require(_amount > 0, "withdraw: only non-zero amounts allowed");

        // make sure the pool is up-to-date
        pokePool(_pid);
        
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        
        require(user.amount >= _amount, "withdraw: amount too large");
        
        // deliver any pending rewards
        _claim(pool, user, msg.sender);

        // update the pool's total deposit
        pool.total = pool.total.sub(_amount);
        
        // update the user's deposit and reward info
        user.amount = user.amount.sub(_amount);
        user.rewardDebt = user.amount.mul(pool.accPerShare).div(1e12);
        
        // send back the staked assets
        pool.token.safeTransfer(address(msg.sender), _amount);
        
        emit Withdraw(msg.sender, _pid, _amount);
    }

    /**
     * @dev Withdraw staked tokens and forego any unclaimed rewards. This is a fail-safe.
     */
    function emergencyWithdraw(
        uint256 _pid
    ) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        uint256 amount = user.amount;
        
        // reset everything to zero
        user.amount = 0;
        user.rewardDebt = 0;
        underpayment[msg.sender] = 0;

        // update the pool's total deposit
        pool.total = pool.total.sub(amount);
        
        // send back the staked assets
        pool.token.safeTransfer(address(msg.sender), amount);
        emit EmergencyWithdraw(msg.sender, _pid, amount);
    }
    
    /**
     * @dev Reclaim stuck tokens (e.g. unexpected external rewards). This is a fail-safe.
     */
    function emergencyReclaim(
        IERC20 _token,
        uint256 _amount
    ) public onlyOwner {
        if (_amount == 0) {
            _amount = _token.balanceOf(address(this));
        }
        
        _token.transfer(msg.sender, _amount);
        emit EmergencyReclaim(msg.sender, address(_token), _amount);
    }
    
    /**
     * @dev Gets the length of the pools array.
     */
    function poolLength() external view returns (uint256 length) {
        return poolInfo.length;
    }
    
    /**
     * @dev Claim rewards not yet distributed for an address.
     * @param pool The staking pool issuing rewards.
     * @param user The staker who earned them.
     * @param to The address to pay. 
     */
    function _claim(
        PoolInfo storage pool,
        UserInfo storage user,
        address to
    ) internal {
        if (user.amount > 0) {
            // calculate the pending reward
            uint256 pending = user.amount
                .mul(pool.accPerShare)
                .div(1e12)
                .sub(user.rewardDebt)
                .add(underpayment[to]);
            
            // send the rewards out
            uint256 payout = _safelyDistribute(to, pending);
            if (payout < pending) {
                underpayment[to] = pending.sub(payout);
            } else {
                underpayment[to] = 0;
            }
            
            emit Claim(to, payout);
        }
    }
    
    /**
     * @dev Safely distribute at most the amount of tokens in holding.
     */
    function _safelyDistribute(
        address _to,
        uint256 _amount
    ) internal returns (uint256 amount) {
        uint256 available = rewardToken.balanceOf(address(this));
        amount = _amount > available ? available : _amount;
        
        vault.issue(
            _to,                // address _beneficiary,
            _amount,            // uint256 _amount,
            block.timestamp,    // uint256 _startAt,
            vestingCliff,       // uint256 _cliff,
            vestingDuration,    // uint256 _duration,
            0                   // uint256 _initialPct
        );
        
        return amount;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"_rewardToken","type":"address"},{"internalType":"uint256","name":"_rewardPerBlock","type":"uint256"},{"internalType":"uint256","name":"_startBlock","type":"uint256"},{"internalType":"uint256","name":"_vestingCliff","type":"uint256"},{"internalType":"uint256","name":"_vestingDuration","type":"uint256"},{"internalType":"contract VestingMultiVault","name":"_vault","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claim","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyReclaim","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","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":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"weight","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalWeight","type":"uint256"}],"name":"TokenAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_beneficiary","type":"address"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_pids","type":"uint256[]"},{"internalType":"address","name":"_beneficiary","type":"address"}],"name":"claimMultiple","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"uint256","name":"_weight","type":"uint256"},{"internalType":"uint256","name":"_power","type":"uint256"},{"internalType":"bool","name":"_shouldUpdate","type":"bool"}],"name":"createPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"duration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"emergencyReclaim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_beneficiary","type":"address"}],"name":"pendingRewards","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"pokePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pokePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"weight","type":"uint256"},{"internalType":"uint256","name":"power","type":"uint256"},{"internalType":"uint256","name":"total","type":"uint256"},{"internalType":"uint256","name":"accPerShare","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_beneficiary","type":"address"}],"name":"power","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewardPerBlock","type":"uint256"}],"name":"setRewardPerBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_duration","type":"uint256"},{"internalType":"uint256","name":"_cliff","type":"uint256"}],"name":"setVestingRules","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_beneficiary","type":"address"}],"name":"totalPendingRewards","outputs":[{"internalType":"uint256","name":"total","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_beneficiary","type":"address"}],"name":"totalPower","outputs":[{"internalType":"uint256","name":"total","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalWeight","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"underpayment","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_weight","type":"uint256"},{"internalType":"uint256","name":"_power","type":"uint256"},{"internalType":"bool","name":"_shouldUpdate","type":"bool"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vault","outputs":[{"internalType":"contract VestingMultiVault","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vestingCliff","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vestingDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000005166e09628b696285e3a151e84fb977736a835750000000000000000000000000000000000000000000000005b18ae9b8cecf0000000000000000000000000000000000000000000000000000000000000c230bc0000000000000000000000000000000000000000000000000000000000f142800000000000000000000000000000000000000000000000000000000000f14280000000000000000000000000b632373aab2d6fb1aeb628bea65a6f4b76a38fbb

-----Decoded View---------------
Arg [0] : _rewardToken (address): 0x5166E09628b696285E3A151e84FB977736a83575
Arg [1] : _rewardPerBlock (uint256): 6564188440000000000
Arg [2] : _startBlock (uint256): 12726460
Arg [3] : _vestingCliff (uint256): 15811200
Arg [4] : _vestingDuration (uint256): 15811200
Arg [5] : _vault (address): 0xb632373Aab2D6fb1aeb628bea65A6F4B76A38fBb

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000005166e09628b696285e3a151e84fb977736a83575
Arg [1] : 0000000000000000000000000000000000000000000000005b18ae9b8cecf000
Arg [2] : 0000000000000000000000000000000000000000000000000000000000c230bc
Arg [3] : 0000000000000000000000000000000000000000000000000000000000f14280
Arg [4] : 0000000000000000000000000000000000000000000000000000000000f14280
Arg [5] : 000000000000000000000000b632373aab2d6fb1aeb628bea65a6f4b76a38fbb

48692:16567:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63422:102;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50291:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50370:26;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;:::i;:::-;;;;;;;;57182:259;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55246:180;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54209:416;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;55595:141;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61166:981;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;50777:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62264:627;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;55748:277;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58303:688;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;12730:148;;;:::i;:::-;;50574:47;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63012:331;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;50221:29;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12079:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50455:64;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;50688:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57601:278;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57980:172;;;:::i;:::-;;59718:222;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54805:136;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56230:803;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59195:320;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53103:648;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60117:962;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;13033:244;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;50257:27;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50179:35;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50096:40;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63422:102;63467:14;63501:8;:15;;;;63494:22;;63422:102;:::o;50291:30::-;;;;:::o;50370:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;57182:259::-;57261:13;57292:11;57306:1;57292:15;;57287:122;57315:8;:15;;;;57309:3;:21;57287:122;;;57362:35;57372:24;57378:3;57383:12;57372:5;:24::i;:::-;57362:5;:9;;:35;;;;:::i;:::-;57354:43;;57332:5;;;;;:::i;:::-;;;;57287:122;;;;57182:259;;;:::o;55246:180::-;12310:12;:10;:12::i;:::-;12299:23;;:7;:5;:7::i;:::-;:23;;;12291:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;55377:9:::1;55359:15;:27;;;;55412:6;55397:12;:21;;;;55246:180:::0;;:::o;54209:416::-;12310:12;:10;:12::i;:::-;12299:23;;:7;:5;:7::i;:::-;:23;;;12291:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;54371:13:::1;54367:57;;;54401:11;:9;:11::i;:::-;54367:57;54458:75;54515:7;54458:38;54474:8;54483:4;54474:14;;;;;;;;:::i;:::-;;;;;;;;;;;;:21;;;54458:11;;:15;;:38;;;;:::i;:::-;:42;;:75;;;;:::i;:::-;54444:11;:89;;;;54570:7;54546:8;54555:4;54546:14;;;;;;;;:::i;:::-;;;;;;;;;;;;:21;;:31;;;;54611:6;54588:8;54597:4;54588:14;;;;;;;;:::i;:::-;;;;;;;;;;;;:20;;:29;;;;54209:416:::0;;;;:::o;55595:141::-;55687:7;55714:14;55722:5;55714:3;:7;;:14;;;;:::i;:::-;55707:21;;55595:141;;;;:::o;61166:981::-;61276:1;61266:7;:11;61258:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;61379:14;61388:4;61379:8;:14::i;:::-;61414:21;61438:8;61447:4;61438:14;;;;;;;;:::i;:::-;;;;;;;;;;;;61414:38;;61463:21;61487:8;:14;61496:4;61487:14;;;;;;;;;;;:26;61502:10;61487:26;;;;;;;;;;;;;;;61463:50;;61557:7;61542:4;:11;;;:22;;61534:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;61656:30;61663:4;61669;61675:10;61656:6;:30::i;:::-;61756:23;61771:7;61756:4;:10;;;:14;;:23;;;;:::i;:::-;61743:4;:10;;:36;;;;61868:24;61884:7;61868:4;:11;;;:15;;:24;;;;:::i;:::-;61854:4;:11;;:38;;;;61921:43;61959:4;61921:33;61937:4;:16;;;61921:4;:11;;;:15;;:33;;;;:::i;:::-;:37;;:43;;;;:::i;:::-;61903:4;:15;;:61;;;;62025:53;62057:10;62070:7;62025:4;:10;;;;;;;;;;;;:23;;;;:53;;;;;:::i;:::-;62125:4;62113:10;62104:35;;;62131:7;62104:35;;;;;;:::i;:::-;;;;;;;;61247:900;;61166:981;;:::o;50777:25::-;;;;:::o;62264:627::-;62339:21;62363:8;62372:4;62363:14;;;;;;;;:::i;:::-;;;;;;;;;;;;62339:38;;62388:21;62412:8;:14;62421:4;62412:14;;;;;;;;;;;:26;62427:10;62412:26;;;;;;;;;;;;;;;62388:50;;62449:14;62466:4;:11;;;62449:28;;62549:1;62535:4;:11;;:15;;;;62579:1;62561:4;:15;;:19;;;;62618:1;62591:12;:24;62604:10;62591:24;;;;;;;;;;;;;;;:28;;;;62689:22;62704:6;62689:4;:10;;;:14;;:22;;;;:::i;:::-;62676:4;:10;;:35;;;;62772:52;62804:10;62817:6;62772:4;:10;;;;;;;;;;;;:23;;;;:52;;;;;:::i;:::-;62870:4;62858:10;62840:43;;;62876:6;62840:43;;;;;;:::i;:::-;;;;;;;;62328:563;;;62264:627;:::o;55748:277::-;55836:13;55867:11;55881:1;55867:15;;55862:131;55890:8;:15;;;;55884:3;:21;55862:131;;;55937:44;55947:33;55962:3;55967:12;55947:14;:33::i;:::-;55937:5;:9;;:44;;;;:::i;:::-;55929:52;;55907:5;;;;;:::i;:::-;;;;55862:131;;;;55748:277;;;:::o;58303:688::-;58369:21;58393:8;58402:4;58393:14;;;;;;;;:::i;:::-;;;;;;;;;;;;58369:38;;58440:4;:20;;;58424:12;:36;58420:75;;58477:7;;;58420:75;58507:19;58529:4;:10;;;58507:32;;58569:1;58554:11;:16;58550:105;;;58610:12;58587:4;:20;;:35;;;;58637:7;;;;58550:105;58667:14;58684:140;58812:11;;58684:109;58781:4;:11;;;58684:78;58747:14;;58684:44;58693:4;:20;;;58715:12;58684:8;:44::i;:::-;:62;;:78;;;;:::i;:::-;:96;;:109;;;;:::i;:::-;:127;;:140;;;;:::i;:::-;58667:157;;58856:79;58891:33;58912:11;58891:16;58902:4;58891:6;:10;;:16;;;;:::i;:::-;:20;;:33;;;;:::i;:::-;58856:4;:16;;;:20;;:79;;;;:::i;:::-;58837:4;:16;;:98;;;;58971:12;58948:4;:20;;:35;;;;58358:633;;;58303:688;;:::o;12730:148::-;12310:12;:10;:12::i;:::-;12299:23;;:7;:5;:7::i;:::-;:23;;;12291:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;12837:1:::1;12800:40;;12821:6;::::0;::::1;;;;;;;;12800:40;;;;;;;;;;;;12868:1;12851:6:::0;::::1;:19;;;;;;;;;;;;;;;;;;12730:148::o:0;50574:47::-;;;;;;;;;;;;;;;;;:::o;63012:331::-;12310:12;:10;:12::i;:::-;12299:23;;:7;:5;:7::i;:::-;:23;;;12291:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;63138:1:::1;63127:7;:12;63123:86;;;63166:6;:16;;;63191:4;63166:31;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63156:41;;63123:86;63229:6;:15;;;63245:10;63257:7;63229:36;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;63298:10;63281:54;;;63318:6;63327:7;63281:54;;;;;;;:::i;:::-;;;;;;;;63012:331:::0;;:::o;50221:29::-;;;;:::o;12079:87::-;12125:7;12152:6;;;;;;;;;;;12145:13;;12079:87;:::o;50455:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;50688:30::-;;;;:::o;57601:278::-;57698:14;57725:21;57749:8;57758:4;57749:14;;;;;;;;:::i;:::-;;;;;;;;;;;;57725:38;;57774:21;57798:8;:14;57807:4;57798:14;;;;;;;;;;;:28;57813:12;57798:28;;;;;;;;;;;;;;;57774:52;;57844:27;57859:4;:11;;;57844:4;:10;;;:14;;:27;;;;:::i;:::-;57837:34;;;;57601:278;;;;:::o;57980:172::-;58019:14;58036:8;:15;;;;58019:32;;58067:11;58062:83;58090:6;58084:3;:12;58062:83;;;58120:13;58129:3;58120:8;:13::i;:::-;58098:5;;;;:::i;:::-;;;58062:83;;;;58008:144;57980:172::o;59718:222::-;59839:9;59834:99;59858:5;;:12;;59854:1;:16;59834:99;;;59892:29;59898:5;;59904:1;59898:8;;;;;;;:::i;:::-;;;;;;;;59908:12;59892:5;:29::i;:::-;59872:3;;;;;:::i;:::-;;;;59834:99;;;;59718:222;;;:::o;54805:136::-;12310:12;:10;:12::i;:::-;12299:23;;:7;:5;:7::i;:::-;:23;;;12291:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;54918:15:::1;54901:14;:32;;;;54805:136:::0;:::o;56230:803::-;56336:14;56363:21;56387:8;56396:4;56387:14;;;;;;;;:::i;:::-;;;;;;;;;;;;56363:38;;56412:21;56436:8;:14;56445:4;56436:14;;;;;;;;;;;:28;56451:12;56436:28;;;;;;;;;;;;;;;56412:52;;56475:19;56497:4;:16;;;56475:38;;56524:19;56546:4;:10;;;56524:32;;56596:4;:20;;;56581:12;:35;:55;;;;;56635:1;56620:11;:16;;56581:55;56577:370;;;56653:14;56670:152;56810:11;;56670:117;56775:4;:11;;;56670:82;56737:14;;56670:44;56679:4;:20;;;56701:12;56670:8;:44::i;:::-;:66;;:82;;;;:::i;:::-;:104;;:117;;;;:::i;:::-;:139;;:152;;;;:::i;:::-;56653:169;;56853:82;56887:33;56908:11;56887:16;56898:4;56887:6;:10;;:16;;;;:::i;:::-;:20;;:33;;;;:::i;:::-;56853:11;:15;;:82;;;;:::i;:::-;56839:96;;56638:309;56577:370;56966:59;57009:4;:15;;;56966:38;56999:4;56966:28;56982:11;56966:4;:11;;;:15;;:28;;;;:::i;:::-;:32;;:38;;;;:::i;:::-;:42;;:59;;;;:::i;:::-;56959:66;;;;;;56230:803;;;;:::o;59195:320::-;59334:14;59343:4;59334:8;:14::i;:::-;59361:21;59385:8;59394:4;59385:14;;;;;;;;:::i;:::-;;;;;;;;;;;;59361:38;;59410:21;59434:8;:14;59443:4;59434:14;;;;;;;;;;;:28;59449:12;59434:28;;;;;;;;;;;;;;;59410:52;;59475:32;59482:4;59488;59494:12;59475:6;:32::i;:::-;59278:237;;59195:320;;:::o;53103:648::-;12310:12;:10;:12::i;:::-;12299:23;;:7;:5;:7::i;:::-;:23;;;12291:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;53266:13:::1;53262:57;;;53296:11;:9;:11::i;:::-;53262:57;53331:23;53372:10;;53357:12;:25;:53;;53400:10;;53357:53;;;53385:12;53357:53;53331:79;;53435:24;53451:7;53435:11;;:15;;:24;;;;:::i;:::-;53421:11;:38;;;;53470:8;53498:234;;;;;;;;53533:6;53498:234;;;;;;53566:7;53498:234;;;;53599:6;53498:234;;;;53631:1;53498:234;;;;53664:1;53498:234;;;;53701:15;53498:234;;::::0;53470:273:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53251:500;53103:648:::0;;;;:::o;60117:962::-;60226:1;60216:7;:11;60208:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;60336:14;60345:4;60336:8;:14::i;:::-;60363:21;60387:8;60396:4;60387:14;;;;;;;;:::i;:::-;;;;;;;;;;;;60363:38;;60412:21;60436:8;:14;60445:4;60436:14;;;;;;;;;;;:26;60451:10;60436:26;;;;;;;;;;;;;;;60412:50;;60523:30;60530:4;60536;60542:10;60523:6;:30::i;:::-;60615:122;60665:10;60699:4;60719:7;60615:4;:10;;;;;;;;;;;;:27;;;;:122;;;;;;:::i;:::-;60807:23;60822:7;60807:4;:10;;;:14;;:23;;;;:::i;:::-;60794:4;:10;;:36;;;;60915:24;60931:7;60915:4;:11;;;:15;;:24;;;;:::i;:::-;60901:4;:11;;:38;;;;60968:43;61006:4;60968:33;60984:4;:16;;;60968:4;:11;;;:15;;:33;;;;:::i;:::-;:37;;:43;;;;:::i;:::-;60950:4;:15;;:61;;;;61057:4;61045:10;61037:34;;;61063:7;61037:34;;;;;;:::i;:::-;;;;;;;;60197:882;;60117:962;;:::o;13033:244::-;12310:12;:10;:12::i;:::-;12299:23;;:7;:5;:7::i;:::-;:23;;;12291:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;13142:1:::1;13122:22;;:8;:22;;;;13114:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;13232:8;13203:38;;13224:6;::::0;::::1;;;;;;;;13203:38;;;;;;;;;;;;13261:8;13252:6;::::0;:17:::1;;;;;;;;;;;;;;;;;;13033:244:::0;:::o;50257:27::-;;;;:::o;50179:35::-;;;:::o;50096:40::-;;;:::o;5711:98::-;5769:7;5800:1;5796;:5;;;;:::i;:::-;5789:12;;5711:98;;;;:::o;10631:::-;10684:7;10711:10;10704:17;;10631:98;:::o;6092:::-;6150:7;6181:1;6177;:5;;;;:::i;:::-;6170:12;;6092:98;;;;:::o;63758:738::-;63904:1;63890:4;:11;;;:15;63886:603;;;63967:15;63985:158;64126:12;:16;64139:2;64126:16;;;;;;;;;;;;;;;;63985:118;64087:4;:15;;;63985:79;64059:4;63985:51;64019:4;:16;;;63985:4;:11;;;:33;;:51;;;;:::i;:::-;:73;;:79;;;;:::i;:::-;:101;;:118;;;;:::i;:::-;:140;;:158;;;;:::i;:::-;63967:176;;64209:14;64226:30;64244:2;64248:7;64226:17;:30::i;:::-;64209:47;;64284:7;64275:6;:16;64271:156;;;64331:19;64343:6;64331:7;:11;;:19;;;;:::i;:::-;64312:12;:16;64325:2;64312:16;;;;;;;;;;;;;;;:38;;;;64271:156;;;64410:1;64391:12;:16;64404:2;64391:16;;;;;;;;;;;;;;;:20;;;;64271:156;64466:2;64460:17;;;64470:6;64460:17;;;;;;:::i;:::-;;;;;;;;63907:582;;63886:603;63758:738;;;:::o;6449:98::-;6507:7;6538:1;6534;:5;;;;:::i;:::-;6527:12;;6449:98;;;;:::o;6848:::-;6906:7;6937:1;6933;:5;;;;:::i;:::-;6926:12;;6848:98;;;;:::o;21950:177::-;22033:86;22053:5;22083:23;;;22108:2;22112:5;22060:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22033:19;:86::i;:::-;21950:177;;;:::o;22135:205::-;22236:96;22256:5;22286:27;;;22315:4;22321:2;22325:5;22263:68;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22236:19;:96::i;:::-;22135:205;;;;:::o;64598:658::-;64698:14;64725:17;64745:11;:21;;;64775:4;64745:36;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;64725:56;;64811:9;64801:7;:19;:41;;64835:7;64801:41;;;64823:9;64801:41;64792:50;;64863:5;:11;;;64889:3;64947:7;65000:15;65054:12;;65106:15;;65161:1;64863:351;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65235:13;64598:658;;;;:::o;24384:761::-;24808:23;24834:69;24862:4;24834:69;;;;;;;;;;;;;;;;;24842:5;24834:27;;;;:69;;;;;:::i;:::-;24808:95;;24938:1;24918:10;:17;:21;24914:224;;;25060:10;25049:30;;;;;;;;;;;;:::i;:::-;25041:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;24914:224;24454:691;24384:761;;:::o;16974:195::-;17077:12;17109:52;17131:6;17139:4;17145:1;17148:12;17109:21;:52::i;:::-;17102:59;;16974:195;;;;;:::o;18026:530::-;18153:12;18211:5;18186:21;:30;;18178:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;18278:18;18289:6;18278:10;:18::i;:::-;18270:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;18404:12;18418:23;18445:6;:11;;18465:5;18473:4;18445:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18403:75;;;;18496:52;18514:7;18523:10;18535:12;18496:17;:52::i;:::-;18489:59;;;;18026:530;;;;;;:::o;14056:422::-;14116:4;14324:12;14435:7;14423:20;14415:28;;14469:1;14462:4;:8;14455:15;;;14056:422;;;:::o;20566:742::-;20681:12;20710:7;20706:595;;;20741:10;20734:17;;;;20706:595;20875:1;20855:10;:17;:21;20851:439;;;21118:10;21112:17;21179:15;21166:10;21162:2;21158:19;21151:44;20851:439;21261:12;21254:20;;;;;;;;;;;:::i;:::-;;;;;;;;20566:742;;;;;;:::o;7:139:1:-;53:5;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;59:87;;;;:::o;169:568::-;242:8;252:6;302:3;295:4;287:6;283:17;279:27;269:2;;310:79;;:::i;:::-;269:2;423:6;410:20;400:30;;453:18;445:6;442:30;439:2;;;475:79;;:::i;:::-;439:2;589:4;581:6;577:17;565:29;;643:3;635:4;627:6;623:17;613:8;609:32;606:41;603:2;;;650:79;;:::i;:::-;603:2;259:478;;;;;:::o;743:133::-;786:5;824:6;811:20;802:29;;840:30;864:5;840:30;:::i;:::-;792:84;;;;:::o;882:137::-;936:5;967:6;961:13;952:22;;983:30;1007:5;983:30;:::i;:::-;942:77;;;;:::o;1025:165::-;1084:5;1122:6;1109:20;1100:29;;1138:46;1178:5;1138:46;:::i;:::-;1090:100;;;;:::o;1196:139::-;1242:5;1280:6;1267:20;1258:29;;1296:33;1323:5;1296:33;:::i;:::-;1248:87;;;;:::o;1341:143::-;1398:5;1429:6;1423:13;1414:22;;1445:33;1472:5;1445:33;:::i;:::-;1404:80;;;;:::o;1490:329::-;1549:6;1598:2;1586:9;1577:7;1573:23;1569:32;1566:2;;;1604:79;;:::i;:::-;1566:2;1724:1;1749:53;1794:7;1785:6;1774:9;1770:22;1749:53;:::i;:::-;1739:63;;1695:117;1556:263;;;;:::o;1825:704::-;1920:6;1928;1936;1985:2;1973:9;1964:7;1960:23;1956:32;1953:2;;;1991:79;;:::i;:::-;1953:2;2139:1;2128:9;2124:17;2111:31;2169:18;2161:6;2158:30;2155:2;;;2191:79;;:::i;:::-;2155:2;2304:80;2376:7;2367:6;2356:9;2352:22;2304:80;:::i;:::-;2286:98;;;;2082:312;2433:2;2459:53;2504:7;2495:6;2484:9;2480:22;2459:53;:::i;:::-;2449:63;;2404:118;1943:586;;;;;:::o;2535:345::-;2602:6;2651:2;2639:9;2630:7;2626:23;2622:32;2619:2;;;2657:79;;:::i;:::-;2619:2;2777:1;2802:61;2855:7;2846:6;2835:9;2831:22;2802:61;:::i;:::-;2792:71;;2748:125;2609:271;;;;:::o;2886:500::-;2967:6;2975;3024:2;3012:9;3003:7;2999:23;2995:32;2992:2;;;3030:79;;:::i;:::-;2992:2;3150:1;3175:66;3233:7;3224:6;3213:9;3209:22;3175:66;:::i;:::-;3165:76;;3121:130;3290:2;3316:53;3361:7;3352:6;3341:9;3337:22;3316:53;:::i;:::-;3306:63;;3261:118;2982:404;;;;;:::o;3392:785::-;3488:6;3496;3504;3512;3561:3;3549:9;3540:7;3536:23;3532:33;3529:2;;;3568:79;;:::i;:::-;3529:2;3688:1;3713:66;3771:7;3762:6;3751:9;3747:22;3713:66;:::i;:::-;3703:76;;3659:130;3828:2;3854:53;3899:7;3890:6;3879:9;3875:22;3854:53;:::i;:::-;3844:63;;3799:118;3956:2;3982:53;4027:7;4018:6;4007:9;4003:22;3982:53;:::i;:::-;3972:63;;3927:118;4084:2;4110:50;4152:7;4143:6;4132:9;4128:22;4110:50;:::i;:::-;4100:60;;4055:115;3519:658;;;;;;;:::o;4183:329::-;4242:6;4291:2;4279:9;4270:7;4266:23;4262:32;4259:2;;;4297:79;;:::i;:::-;4259:2;4417:1;4442:53;4487:7;4478:6;4467:9;4463:22;4442:53;:::i;:::-;4432:63;;4388:117;4249:263;;;;:::o;4518:351::-;4588:6;4637:2;4625:9;4616:7;4612:23;4608:32;4605:2;;;4643:79;;:::i;:::-;4605:2;4763:1;4788:64;4844:7;4835:6;4824:9;4820:22;4788:64;:::i;:::-;4778:74;;4734:128;4595:274;;;;:::o;4875:474::-;4943:6;4951;5000:2;4988:9;4979:7;4975:23;4971:32;4968:2;;;5006:79;;:::i;:::-;4968:2;5126:1;5151:53;5196:7;5187:6;5176:9;5172:22;5151:53;:::i;:::-;5141:63;;5097:117;5253:2;5279:53;5324:7;5315:6;5304:9;5300:22;5279:53;:::i;:::-;5269:63;;5224:118;4958:391;;;;;:::o;5355:474::-;5423:6;5431;5480:2;5468:9;5459:7;5455:23;5451:32;5448:2;;;5486:79;;:::i;:::-;5448:2;5606:1;5631:53;5676:7;5667:6;5656:9;5652:22;5631:53;:::i;:::-;5621:63;;5577:117;5733:2;5759:53;5804:7;5795:6;5784:9;5780:22;5759:53;:::i;:::-;5749:63;;5704:118;5438:391;;;;;:::o;5835:759::-;5918:6;5926;5934;5942;5991:3;5979:9;5970:7;5966:23;5962:33;5959:2;;;5998:79;;:::i;:::-;5959:2;6118:1;6143:53;6188:7;6179:6;6168:9;6164:22;6143:53;:::i;:::-;6133:63;;6089:117;6245:2;6271:53;6316:7;6307:6;6296:9;6292:22;6271:53;:::i;:::-;6261:63;;6216:118;6373:2;6399:53;6444:7;6435:6;6424:9;6420:22;6399:53;:::i;:::-;6389:63;;6344:118;6501:2;6527:50;6569:7;6560:6;6549:9;6545:22;6527:50;:::i;:::-;6517:60;;6472:115;5949:645;;;;;;;:::o;6600:118::-;6687:24;6705:5;6687:24;:::i;:::-;6682:3;6675:37;6665:53;;:::o;6724:373::-;6828:3;6856:38;6888:5;6856:38;:::i;:::-;6910:88;6991:6;6986:3;6910:88;:::i;:::-;6903:95;;7007:52;7052:6;7047:3;7040:4;7033:5;7029:16;7007:52;:::i;:::-;7084:6;7079:3;7075:16;7068:23;;6832:265;;;;;:::o;7103:157::-;7203:50;7247:5;7203:50;:::i;:::-;7198:3;7191:63;7181:79;;:::o;7266:183::-;7379:63;7436:5;7379:63;:::i;:::-;7374:3;7367:76;7357:92;;:::o;7455:147::-;7550:45;7589:5;7550:45;:::i;:::-;7545:3;7538:58;7528:74;;:::o;7608:364::-;7696:3;7724:39;7757:5;7724:39;:::i;:::-;7779:71;7843:6;7838:3;7779:71;:::i;:::-;7772:78;;7859:52;7904:6;7899:3;7892:4;7885:5;7881:16;7859:52;:::i;:::-;7936:29;7958:6;7936:29;:::i;:::-;7931:3;7927:39;7920:46;;7700:272;;;;;:::o;7978:366::-;8120:3;8141:67;8205:2;8200:3;8141:67;:::i;:::-;8134:74;;8217:93;8306:3;8217:93;:::i;:::-;8335:2;8330:3;8326:12;8319:19;;8124:220;;;:::o;8350:366::-;8492:3;8513:67;8577:2;8572:3;8513:67;:::i;:::-;8506:74;;8589:93;8678:3;8589:93;:::i;:::-;8707:2;8702:3;8698:12;8691:19;;8496:220;;;:::o;8722:366::-;8864:3;8885:67;8949:2;8944:3;8885:67;:::i;:::-;8878:74;;8961:93;9050:3;8961:93;:::i;:::-;9079:2;9074:3;9070:12;9063:19;;8868:220;;;:::o;9094:366::-;9236:3;9257:67;9321:2;9316:3;9257:67;:::i;:::-;9250:74;;9333:93;9422:3;9333:93;:::i;:::-;9451:2;9446:3;9442:12;9435:19;;9240:220;;;:::o;9466:366::-;9608:3;9629:67;9693:2;9688:3;9629:67;:::i;:::-;9622:74;;9705:93;9794:3;9705:93;:::i;:::-;9823:2;9818:3;9814:12;9807:19;;9612:220;;;:::o;9838:366::-;9980:3;10001:67;10065:2;10060:3;10001:67;:::i;:::-;9994:74;;10077:93;10166:3;10077:93;:::i;:::-;10195:2;10190:3;10186:12;10179:19;;9984:220;;;:::o;10210:366::-;10352:3;10373:67;10437:2;10432:3;10373:67;:::i;:::-;10366:74;;10449:93;10538:3;10449:93;:::i;:::-;10567:2;10562:3;10558:12;10551:19;;10356:220;;;:::o;10582:366::-;10724:3;10745:67;10809:2;10804:3;10745:67;:::i;:::-;10738:74;;10821:93;10910:3;10821:93;:::i;:::-;10939:2;10934:3;10930:12;10923:19;;10728:220;;;:::o;10954:118::-;11041:24;11059:5;11041:24;:::i;:::-;11036:3;11029:37;11019:53;;:::o;11078:271::-;11208:3;11230:93;11319:3;11310:6;11230:93;:::i;:::-;11223:100;;11340:3;11333:10;;11212:137;;;;:::o;11355:222::-;11448:4;11486:2;11475:9;11471:18;11463:26;;11499:71;11567:1;11556:9;11552:17;11543:6;11499:71;:::i;:::-;11453:124;;;;:::o;11583:442::-;11732:4;11770:2;11759:9;11755:18;11747:26;;11783:71;11851:1;11840:9;11836:17;11827:6;11783:71;:::i;:::-;11864:72;11932:2;11921:9;11917:18;11908:6;11864:72;:::i;:::-;11946;12014:2;12003:9;11999:18;11990:6;11946:72;:::i;:::-;11737:288;;;;;;:::o;12031:332::-;12152:4;12190:2;12179:9;12175:18;12167:26;;12203:71;12271:1;12260:9;12256:17;12247:6;12203:71;:::i;:::-;12284:72;12352:2;12341:9;12337:18;12328:6;12284:72;:::i;:::-;12157:206;;;;;:::o;12369:791::-;12610:4;12648:3;12637:9;12633:19;12625:27;;12662:71;12730:1;12719:9;12715:17;12706:6;12662:71;:::i;:::-;12743:72;12811:2;12800:9;12796:18;12787:6;12743:72;:::i;:::-;12825;12893:2;12882:9;12878:18;12869:6;12825:72;:::i;:::-;12907;12975:2;12964:9;12960:18;12951:6;12907:72;:::i;:::-;12989:73;13057:3;13046:9;13042:19;13033:6;12989:73;:::i;:::-;13072:81;13148:3;13137:9;13133:19;13124:6;13072:81;:::i;:::-;12615:545;;;;;;;;;:::o;13166:248::-;13272:4;13310:2;13299:9;13295:18;13287:26;;13323:84;13404:1;13393:9;13389:17;13380:6;13323:84;:::i;:::-;13277:137;;;;:::o;13420:801::-;13666:4;13704:3;13693:9;13689:19;13681:27;;13718:84;13799:1;13788:9;13784:17;13775:6;13718:84;:::i;:::-;13812:72;13880:2;13869:9;13865:18;13856:6;13812:72;:::i;:::-;13894;13962:2;13951:9;13947:18;13938:6;13894:72;:::i;:::-;13976;14044:2;14033:9;14029:18;14020:6;13976:72;:::i;:::-;14058:73;14126:3;14115:9;14111:19;14102:6;14058:73;:::i;:::-;14141;14209:3;14198:9;14194:19;14185:6;14141:73;:::i;:::-;13671:550;;;;;;;;;:::o;14227:274::-;14346:4;14384:2;14373:9;14369:18;14361:26;;14397:97;14491:1;14480:9;14476:17;14467:6;14397:97;:::i;:::-;14351:150;;;;:::o;14507:313::-;14620:4;14658:2;14647:9;14643:18;14635:26;;14707:9;14701:4;14697:20;14693:1;14682:9;14678:17;14671:47;14735:78;14808:4;14799:6;14735:78;:::i;:::-;14727:86;;14625:195;;;;:::o;14826:419::-;14992:4;15030:2;15019:9;15015:18;15007:26;;15079:9;15073:4;15069:20;15065:1;15054:9;15050:17;15043:47;15107:131;15233:4;15107:131;:::i;:::-;15099:139;;14997:248;;;:::o;15251:419::-;15417:4;15455:2;15444:9;15440:18;15432:26;;15504:9;15498:4;15494:20;15490:1;15479:9;15475:17;15468:47;15532:131;15658:4;15532:131;:::i;:::-;15524:139;;15422:248;;;:::o;15676:419::-;15842:4;15880:2;15869:9;15865:18;15857:26;;15929:9;15923:4;15919:20;15915:1;15904:9;15900:17;15893:47;15957:131;16083:4;15957:131;:::i;:::-;15949:139;;15847:248;;;:::o;16101:419::-;16267:4;16305:2;16294:9;16290:18;16282:26;;16354:9;16348:4;16344:20;16340:1;16329:9;16325:17;16318:47;16382:131;16508:4;16382:131;:::i;:::-;16374:139;;16272:248;;;:::o;16526:419::-;16692:4;16730:2;16719:9;16715:18;16707:26;;16779:9;16773:4;16769:20;16765:1;16754:9;16750:17;16743:47;16807:131;16933:4;16807:131;:::i;:::-;16799:139;;16697:248;;;:::o;16951:419::-;17117:4;17155:2;17144:9;17140:18;17132:26;;17204:9;17198:4;17194:20;17190:1;17179:9;17175:17;17168:47;17232:131;17358:4;17232:131;:::i;:::-;17224:139;;17122:248;;;:::o;17376:419::-;17542:4;17580:2;17569:9;17565:18;17557:26;;17629:9;17623:4;17619:20;17615:1;17604:9;17600:17;17593:47;17657:131;17783:4;17657:131;:::i;:::-;17649:139;;17547:248;;;:::o;17801:419::-;17967:4;18005:2;17994:9;17990:18;17982:26;;18054:9;18048:4;18044:20;18040:1;18029:9;18025:17;18018:47;18082:131;18208:4;18082:131;:::i;:::-;18074:139;;17972:248;;;:::o;18226:222::-;18319:4;18357:2;18346:9;18342:18;18334:26;;18370:71;18438:1;18427:9;18423:17;18414:6;18370:71;:::i;:::-;18324:124;;;;:::o;18454:332::-;18575:4;18613:2;18602:9;18598:18;18590:26;;18626:71;18694:1;18683:9;18679:17;18670:6;18626:71;:::i;:::-;18707:72;18775:2;18764:9;18760:18;18751:6;18707:72;:::i;:::-;18580:206;;;;;:::o;18873:98::-;18924:6;18958:5;18952:12;18942:22;;18931:40;;;:::o;18977:99::-;19029:6;19063:5;19057:12;19047:22;;19036:40;;;:::o;19082:147::-;19183:11;19220:3;19205:18;;19195:34;;;;:::o;19235:169::-;19319:11;19353:6;19348:3;19341:19;19393:4;19388:3;19384:14;19369:29;;19331:73;;;;:::o;19410:305::-;19450:3;19469:20;19487:1;19469:20;:::i;:::-;19464:25;;19503:20;19521:1;19503:20;:::i;:::-;19498:25;;19657:1;19589:66;19585:74;19582:1;19579:81;19576:2;;;19663:18;;:::i;:::-;19576:2;19707:1;19704;19700:9;19693:16;;19454:261;;;;:::o;19721:185::-;19761:1;19778:20;19796:1;19778:20;:::i;:::-;19773:25;;19812:20;19830:1;19812:20;:::i;:::-;19807:25;;19851:1;19841:2;;19856:18;;:::i;:::-;19841:2;19898:1;19895;19891:9;19886:14;;19763:143;;;;:::o;19912:348::-;19952:7;19975:20;19993:1;19975:20;:::i;:::-;19970:25;;20009:20;20027:1;20009:20;:::i;:::-;20004:25;;20197:1;20129:66;20125:74;20122:1;20119:81;20114:1;20107:9;20100:17;20096:105;20093:2;;;20204:18;;:::i;:::-;20093:2;20252:1;20249;20245:9;20234:20;;19960:300;;;;:::o;20266:191::-;20306:4;20326:20;20344:1;20326:20;:::i;:::-;20321:25;;20360:20;20378:1;20360:20;:::i;:::-;20355:25;;20399:1;20396;20393:8;20390:2;;;20404:18;;:::i;:::-;20390:2;20449:1;20446;20442:9;20434:17;;20311:146;;;;:::o;20463:96::-;20500:7;20529:24;20547:5;20529:24;:::i;:::-;20518:35;;20508:51;;;:::o;20565:90::-;20599:7;20642:5;20635:13;20628:21;20617:32;;20607:48;;;:::o;20661:109::-;20711:7;20740:24;20758:5;20740:24;:::i;:::-;20729:35;;20719:51;;;:::o;20776:126::-;20813:7;20853:42;20846:5;20842:54;20831:65;;20821:81;;;:::o;20908:77::-;20945:7;20974:5;20963:16;;20953:32;;;:::o;20991:152::-;21054:9;21087:50;21131:5;21087:50;:::i;:::-;21074:63;;21064:79;;;:::o;21149:126::-;21212:9;21245:24;21263:5;21245:24;:::i;:::-;21232:37;;21222:53;;;:::o;21281:178::-;21357:9;21390:63;21447:5;21390:63;:::i;:::-;21377:76;;21367:92;;;:::o;21465:139::-;21541:9;21574:24;21592:5;21574:24;:::i;:::-;21561:37;;21551:53;;;:::o;21610:121::-;21668:9;21701:24;21719:5;21701:24;:::i;:::-;21688:37;;21678:53;;;:::o;21737:307::-;21805:1;21815:113;21829:6;21826:1;21823:13;21815:113;;;21914:1;21909:3;21905:11;21899:18;21895:1;21890:3;21886:11;21879:39;21851:2;21848:1;21844:10;21839:15;;21815:113;;;21946:6;21943:1;21940:13;21937:2;;;22026:1;22017:6;22012:3;22008:16;22001:27;21937:2;21786:258;;;;:::o;22050:233::-;22089:3;22112:24;22130:5;22112:24;:::i;:::-;22103:33;;22158:66;22151:5;22148:77;22145:2;;;22228:18;;:::i;:::-;22145:2;22275:1;22268:5;22264:13;22257:20;;22093:190;;;:::o;22289:180::-;22337:77;22334:1;22327:88;22434:4;22431:1;22424:15;22458:4;22455:1;22448:15;22475:180;22523:77;22520:1;22513:88;22620:4;22617:1;22610:15;22644:4;22641:1;22634:15;22661:180;22709:77;22706:1;22699:88;22806:4;22803:1;22796:15;22830:4;22827:1;22820:15;22847:117;22956:1;22953;22946:12;22970:117;23079:1;23076;23069:12;23093:117;23202:1;23199;23192:12;23216:117;23325:1;23322;23315:12;23339:117;23448:1;23445;23438:12;23462:102;23503:6;23554:2;23550:7;23545:2;23538:5;23534:14;23530:28;23520:38;;23510:54;;;:::o;23570:176::-;23710:28;23706:1;23698:6;23694:14;23687:52;23676:70;:::o;23752:225::-;23892:34;23888:1;23880:6;23876:14;23869:58;23961:8;23956:2;23948:6;23944:15;23937:33;23858:119;:::o;23983:225::-;24123:34;24119:1;24111:6;24107:14;24100:58;24192:8;24187:2;24179:6;24175:15;24168:33;24089:119;:::o;24214:226::-;24354:34;24350:1;24342:6;24338:14;24331:58;24423:9;24418:2;24410:6;24406:15;24399:34;24320:120;:::o;24446:182::-;24586:34;24582:1;24574:6;24570:14;24563:58;24552:76;:::o;24634:225::-;24774:34;24770:1;24762:6;24758:14;24751:58;24843:8;24838:2;24830:6;24826:15;24819:33;24740:119;:::o;24865:179::-;25005:31;25001:1;24993:6;24989:14;24982:55;24971:73;:::o;25050:229::-;25190:34;25186:1;25178:6;25174:14;25167:58;25259:12;25254:2;25246:6;25242:15;25235:37;25156:123;:::o;25285:122::-;25358:24;25376:5;25358:24;:::i;:::-;25351:5;25348:35;25338:2;;25397:1;25394;25387:12;25338:2;25328:79;:::o;25413:116::-;25483:21;25498:5;25483:21;:::i;:::-;25476:5;25473:32;25463:2;;25519:1;25516;25509:12;25463:2;25453:76;:::o;25535:148::-;25621:37;25652:5;25621:37;:::i;:::-;25614:5;25611:48;25601:2;;25673:1;25670;25663:12;25601:2;25591:92;:::o;25689:122::-;25762:24;25780:5;25762:24;:::i;:::-;25755:5;25752:35;25742:2;;25801:1;25798;25791:12;25742:2;25732:79;:::o

ipfs://4743a0408667548d19422f82bea696f67bed00cf56efd6092a28b9b129d6f838