Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• 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 _functionCallWithValue(addre ...
• 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 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 ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• interface IStakedDVF
•    - function balanceOf(address account)
•    - function transfer(address dst, uint r ...
•    - function enter(uint256 _amount)
•    - function leave(uint256 _share)
•    - function takeVoteSnapshotAtBlock()
•    - function balanceOfAt(address account, ...
•  contract SupporterVester *
•    - function beneficiary()
•    - function delegateForVoting()
•    - function cliff()
•    - function start()
•    - function duration()
•    - function released()
•    - function release()
•    - function _releasableAmount()
•    - function _vestedAmount()
•    - function stake()
•    - function unstake()
•    - function unstakeAndRelease()
•    - function nominateDelegate(address _ne ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

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 in 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");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        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);
            }
        }
    }
}

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

/**
 * @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 SafeMath for uint256;
    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).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _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");
        }
    }
}

library SafeMath {
    /**
     * @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) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @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 sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @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) {
        // 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 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * 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) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * 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) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts 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 mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message 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, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

interface IStakedDVF {
    function balanceOf(address account) external view returns (uint);
    function transfer(address dst, uint rawAmount) external returns (bool);
    function enter(uint256 _amount) external returns (bool);
    function leave(uint256 _share) external returns (bool);
    function takeVoteSnapshotAtBlock() external returns (uint);
    function balanceOfAt(address account, uint256 snapshotId) external view returns (uint);
}

/**
 * @title SupporterVester
 * @dev A token holder contract that can release its token balance gradually like a
 * typical vesting scheme, with a cliff and vesting period.
 */
contract SupporterVester {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    event TokensReleased(address token, uint256 amount);

    // beneficiary of tokens after they are released
    address private _beneficiary;
    address public _delegateForVoting;

    modifier onlyBeneficiary() {
      require (msg.sender == _beneficiary);
      _;
    }

    IERC20 public _dvf;
    IStakedDVF public _xdvf;

    // Durations and timestamps are expressed in UNIX time, the same units as block.timestamp.
    uint256 private _cliff;
    uint256 private _start;
    uint256 private _duration;

    uint256 private _released;

    /**
     * @dev Creates a vesting contract that vests its balance of any ERC20 token to the
     * beneficiary, gradually in a linear fashion until start + duration. By then all
     * of the balance will have vested.
     * @param vestingBeneficiary address of the beneficiary to whom vested tokens are transferred
     * @param cliffDuration duration in seconds of the cliff in which tokens will begin to vest
     * @param vestingStart the time (as Unix time) at which point vesting starts
     * @param vestingDuration duration in seconds of the period in which the tokens will vest
     */
    constructor (
      address dvf,
      address xdvf,
      address vestingBeneficiary,
      uint256 vestingStart,
      uint256 cliffDuration,
      uint256 vestingDuration) public {
        require(vestingBeneficiary != address(0), "Vesting: beneficiary is the zero address");
        // solhint-disable-next-line max-line-length
        require(cliffDuration <= vestingDuration, "Vesting: cliff is longer than duration");
        require(vestingDuration > 0, "Vesting: duration is 0");
        // solhint-disable-next-line max-line-length
        require(vestingStart.add(vestingDuration) > block.timestamp, "Vesting: final time is before current time");

        _beneficiary = vestingBeneficiary;
        _duration = vestingDuration;
        _cliff = vestingStart.add(cliffDuration);
        _start = vestingStart;
        _dvf = IERC20(dvf);
        _xdvf = IStakedDVF(xdvf);
    }

    /**
     * @return the beneficiary of the tokens.
     */
    function beneficiary() public view returns (address) {
        return _beneficiary;
    }

    /**
     * @return the nominated delegate who can vote on behalf of beneficiary
     */
    function delegateForVoting() public view returns (address) {
        if (_delegateForVoting != address(0)) return _delegateForVoting;
        return _beneficiary;
    }

    /**
     * @return the cliff time of the token vesting.
     */
    function cliff() public view returns (uint256) {
        return _cliff;
    }

    /**
     * @return the start time of the token vesting.
     */
    function start() public view returns (uint256) {
        return _start;
    }

    /**
     * @return the duration of the token vesting.
     */
    function duration() public view returns (uint256) {
        return _duration;
    }

    /**
     * @return the amount of the token released.
     */
    function released() public view returns (uint256) {
        return _released;
    }

    /**
     * @notice Transfers vested tokens to beneficiary.
     */
    function release() public {
        uint256 unreleased = _releasableAmount();

        require(unreleased > 0, "Vesting: no tokens are due");

        _released = _released.add(unreleased);

        _dvf.safeTransfer(_beneficiary, unreleased);

        emit TokensReleased(address(_dvf), unreleased);
    }

    /**
     * @dev Calculates the amount that has already vested but hasn't been released yet.
     */
    function _releasableAmount() private view returns (uint256) {
        return _vestedAmount().sub(_released);
    }

    /**
     * @dev Calculates the amount that has already vested.
     */
    function _vestedAmount() private view returns (uint256) {
        uint256 currentBalance = _dvf.balanceOf(address(this));
        uint256 totalBalance = currentBalance.add(_released);

        if (block.timestamp < _cliff) {
            return 0;
        } else if (block.timestamp >= _start.add(_duration)) {
            return totalBalance;
        } else {
            return totalBalance.mul(block.timestamp.sub(_start)).div(_duration);
        }
    }

    /**
     * @notice Stakes the tokens in the vesting contract on behalf of beneficiary.
     */
    function stake() onlyBeneficiary public {
        uint256 currentBalance = _dvf.balanceOf(address(this));

        require(currentBalance > 0, "Vesting: No unstaked tokens");
        _dvf.approve(address(_xdvf), currentBalance);
        _xdvf.enter(currentBalance);
    }

    /**
     * @notice Unstakes the tokens in the vesting contract on behalf of beneficiary.
     */
    function unstake() onlyBeneficiary public {
        uint256 currentBalance = _xdvf.balanceOf(address(this));

        require(currentBalance > 0, "Vesting: No staked tokens");

        _xdvf.leave(currentBalance);
    }

    function unstakeAndRelease() onlyBeneficiary public {
        unstake();
        release();
    }

    function nominateDelegate(address _newDelegate) onlyBeneficiary public {
        _delegateForVoting = _newDelegate;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"dvf","type":"address"},{"internalType":"address","name":"xdvf","type":"address"},{"internalType":"address","name":"vestingBeneficiary","type":"address"},{"internalType":"uint256","name":"vestingStart","type":"uint256"},{"internalType":"uint256","name":"cliffDuration","type":"uint256"},{"internalType":"uint256","name":"vestingDuration","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensReleased","type":"event"},{"inputs":[],"name":"_delegateForVoting","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_dvf","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_xdvf","outputs":[{"internalType":"contract IStakedDVF","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"beneficiary","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cliff","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"delegateForVoting","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"duration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_newDelegate","type":"address"}],"name":"nominateDelegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"start","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unstakeAndRelease","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

17588:5408:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20038:171;;;:::i;:::-;;;;;;;;;;;;;;;;;;;22870:123;;;;;;;;;;;;;;;;-1:-1:-1;22870:123:0;;;;:::i;:::-;;20602:85;;;:::i;:::-;;;;;;;;;;;;;;;;20288:79;;;:::i;22529:225::-;;;:::i;19844:91::-;;;:::i;22140:277::-;;;:::i;22762:100::-;;;:::i;17837:33::-;;;:::i;20930:316::-;;;:::i;20763:85::-;;;:::i;20446:79::-;;;:::i;17977:18::-;;;:::i;18002:23::-;;;:::i;20038:171::-;20112:18;;20088:7;;20112:32;:18;:32;20108:63;;-1:-1:-1;20153:18:0;;;;20146:25;;20108:63;-1:-1:-1;20189:12:0;;;;20038:171;;:::o;22870:123::-;17938:12;;;;17924:10;:26;17915:36;;;;;;22952:18:::1;:33:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;22870:123::o;20602:85::-;20670:9;;20602:85;:::o;20288:79::-;20353:6;;20288:79;:::o;22529:225::-;17938:12;;;;17924:10;:26;17915:36;;;;;;22607:5:::1;::::0;:30:::1;::::0;;;;;22631:4:::1;22607:30;::::0;::::1;::::0;;;22582:22:::1;::::0;22607:5:::1;;::::0;:15:::1;::::0;:30;;;;;::::1;::::0;;;;;;;;:5;:30;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;22607:30:0;;-1:-1:-1;22658:18:0;22650:56:::1;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;22719:5;::::0;:27:::1;::::0;;;;;::::1;::::0;::::1;::::0;;;;;:5:::1;::::0;;::::1;::::0;:11:::1;::::0;:27;;;;;::::1;::::0;;;;;;;;;:5:::1;::::0;:27;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;;;22529:225:0:o;19844:91::-;19888:7;19915:12;;;19844:91;:::o;22140:277::-;17938:12;;;;17924:10;:26;17915:36;;;;;;22216:4:::1;::::0;:29:::1;::::0;;;;;22239:4:::1;22216:29;::::0;::::1;::::0;;;22191:22:::1;::::0;22216:4:::1;;::::0;:14:::1;::::0;:29;;;;;::::1;::::0;;;;;;;;:4;:29;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;22216:29:0;;-1:-1:-1;22266:18:0;22258:58:::1;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;22327:4;::::0;22348:5:::1;::::0;22327:44:::1;::::0;;;;;:4:::1;22348:5:::0;;::::1;22327:44;::::0;::::1;::::0;;;;;;;;;:4;;;::::1;::::0;:12:::1;::::0;:44;;;;;::::1;::::0;;;;;;;;:4:::1;::::0;:44;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;;22382:5:0::1;::::0;:27:::1;::::0;;;;;::::1;::::0;::::1;::::0;;;;;:5:::1;::::0;;::::1;::::0;:11:::1;::::0;:27;;;;;22327:44:::1;::::0;22382:27;;;;;;;;:5:::1;::::0;:27;::::1;;::::0;::::1;;;;::::0;::::1;22762:100:::0;17938:12;;;;17924:10;:26;17915:36;;;;;;22825:9:::1;:7;:9::i;:::-;22845;:7;:9::i;:::-;22762:100::o:0;17837:33::-;;;;;;:::o;20930:316::-;20967:18;20988:19;:17;:19::i;:::-;20967:40;;21041:1;21028:10;:14;21020:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21098:9;;:25;;21112:10;21098:13;:25::i;:::-;21086:9;:37;21154:12;;21136:4;;:43;;21154:12;21136:4;;;;21154:12;21168:10;21136:17;:43::i;:::-;21220:4;;21197:41;;;21220:4;;;;21197:41;;;;;;;;;;;;;;;;;;;;20930:316;:::o;20763:85::-;20831:9;;20763:85;:::o;20446:79::-;20511:6;;20446:79;:::o;17977:18::-;;;;;;:::o;18002:23::-;;;;;;:::o;12487:181::-;12545:7;12577:5;;;12601:6;;;;12593:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12659:1;-1:-1:-1;12487:181:0;;;;;:::o;21361:116::-;21412:7;21439:30;21459:9;;21439:15;:13;:15::i;:::-;:19;;:30::i;:::-;21432:37;;21361:116;:::o;9151:177::-;9261:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9284:23;9261:58;;;9234:86;;9254:5;;9234:19;:86::i;21563:467::-;21655:4;;:29;;;;;;21678:4;21655:29;;;;;;21610:7;;;;21655:4;;;;;:14;;:29;;;;;;;;;;;;;;;:4;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21655:29:0;21737:9;;21655:29;;-1:-1:-1;21695:20:0;;21718:29;;21655;;21718:18;:29::i;:::-;21695:52;;21782:6;;21764:15;:24;21760:263;;;21812:1;21805:8;;;;;;21760:263;21865:9;;21854:6;;:21;;:10;:21::i;:::-;21835:15;:40;21831:192;;21899:12;-1:-1:-1;21892:19:0;;-1:-1:-1;21892:19:0;21831:192;21951:60;22001:9;;21951:45;21968:27;21988:6;;21968:15;:19;;:27;;;;:::i;:::-;21951:12;;:16;:45::i;:::-;:49;;:60::i;:::-;21944:67;;;;;;12951:136;13009:7;13036:43;13040:1;13043;13036:43;;;;;;;;;;;;;;;;;:3;:43::i;11456:761::-;11880:23;11906:69;11934:4;11906:69;;;;;;;;;;;;;;;;;11914:5;11906:27;;;;:69;;;;;:::i;:::-;11990:17;;11880:95;;-1:-1:-1;11990:21:0;11986:224;;12132:10;12121:30;;;;;;;;;;;;;;;-1:-1:-1;12121:30:0;12113:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13841:471;13899:7;14144:6;14140:47;;-1:-1:-1;14174:1:0;14167:8;;14140:47;14211:5;;;14215:1;14211;:5;:1;14235:5;;;;;:10;14227:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14788:132;14846:7;14873:39;14877:1;14880;14873:39;;;;;;;;;;;;;;;;;:3;:39::i;13390:192::-;13476:7;13512:12;13504:6;;;;13496:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;13548:5:0;;;13390:192::o;3590:196::-;3693:12;3725:53;3748:6;3756:4;3762:1;3765:12;3725:22;:53::i;:::-;3718:60;3590:196;-1:-1:-1;;;;3590:196:0:o;15416:278::-;15502:7;15537:12;15530:5;15522:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15561:9;15577:1;15573;:5;;;;;;;15416:278;-1:-1:-1;;;;;15416:278:0:o;4967:979::-;5097:12;5130:18;5141:6;5130:10;:18::i;:::-;5122:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5256:12;5270:23;5297:6;:11;;5317:8;5328:4;5297:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5255:78;;;;5348:7;5344:595;;;5379:10;-1:-1:-1;5372:17:0;;-1:-1:-1;5372:17:0;5344:595;5493:17;;:21;5489:439;;5756:10;5750:17;5817:15;5804:10;5800:2;5796:19;5789:44;5704:148;5892:20;;;;;;;;;;;;;;;;;;;;5899:12;;5892:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;672:422;1039:20;1078:8;;;672:422::o

ipfs://cc3e7dd31a76853f2598002d3f315815bd3dc12cf7ee74bdcc650f3b2ce232e8