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(
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResult(
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function _callOptionalReturn(IERC20 t ...
•  contract VestingEscrow is Reentran ... *
•    - function add_tokens(uint256 _amount)
•    - function fund(address[100] memory _re ...
•    - function rug_pull(address _target)
•    - function toggle_disable(address _reci ...
•    - function disable_can_disable()
•    - function disable_fund_admins()
•    - function _total_vested_of(address _re ...
•    - function _total_vested()
•    - function vestedSupply()
•    - function lockedSupply()
•    - function vestedOf(address _recipient)
•    - function balanceOf(address _recipient ...
•    - function lockedOf(address _recipient)
•    - function claim(address addr)
•    - function commit_transfer_ownership(ad ...
•    - function accept_transfer_ownership()
•    - function min(uint256 a, uint256 b)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-02-22
*/

// Sources flattened with hardhat v2.6.1 https://hardhat.org

// File @openzeppelin/contracts/token/ERC20/[email protected]


// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)

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/contracts/utils/[email protected]


// OpenZeppelin Contracts v4.4.1 (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;
        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");

        (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");

        (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");

        (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");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


// File @openzeppelin/contracts/token/ERC20/utils/[email protected]


// OpenZeppelin Contracts v4.4.1 (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'
        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
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}


// File @openzeppelin/contracts/security/[email protected]


// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}


// File contracts/Vesting/VestingEscrow.sol

pragma solidity 0.8.10;

/***
 *@title Vesting Escrow
 *@author InsureDAO
 * SPDX-License-Identifier: MIT
 *@notice Vests `InsureToken` tokens for multiple addresses over multiple vesting periods
 */

//libraries



contract VestingEscrow is ReentrancyGuard {
    using SafeERC20
    for IERC20;

    event Fund(address indexed recipient, uint256 amount);
    event Claim(address indexed recipient, uint256 claimed);
    event RugPull(address recipient, uint256 rugged);
    event ToggleDisable(address recipient, bool disabled);
    event CommitOwnership(address admin);
    event AcceptOwnership(address admin);


    address public token; //address of $INSURE
    uint256 public start_time;
    uint256 public end_time;
    mapping(address => uint256) public initial_locked;
    mapping(address => uint256) public total_claimed;
    mapping(address => bool) public is_ragged;

    uint256 public initial_locked_supply;
    uint256 public unallocated_supply;
    uint256 public rugged_amount;

    bool public can_disable;
    mapping(address => uint256) public disabled_at;

    address public admin;
    address public future_admin;

    bool public fund_admins_enabled;
    mapping(address => bool) public fund_admins;



    /***
     *@param _token Address of the ERC20 token being distributed
     *@param _start_time Timestamp at which the distribution starts. Should be in
     *    the future, so that we have enough time to VoteLock everyone
     *@param _end_time Time until everything should be vested
     *@param _can_disable Whether admin can disable accounts in this deployment.
     *@param _fund_admins Temporary admin accounts used only for funding
     */
    constructor(
        address _token,
        uint256 _start_time,
        uint256 _end_time,
        bool _can_disable,
        address[4] memory _fund_admins
    ) {
        require(_start_time >= block.timestamp);
        require(_end_time > _start_time);

        token = _token;
        admin = msg.sender;
        start_time = _start_time;
        end_time = _end_time;
        can_disable = _can_disable;

        bool _fund_admins_enabled = false;
        uint256 _length = _fund_admins.length;
        for (uint256 i; i < _length;) {
            address addr = _fund_admins[i];
            if (addr != address(0)) {
                fund_admins[addr] = true;
                if (!_fund_admins_enabled) {
                    _fund_admins_enabled = true;
                    fund_admins_enabled = true;
                }
            }
            unchecked {
                ++i;
            }
        }
    }


    /***
     *@notice Transfer vestable tokens into the contract
     *@dev Handled separate from `fund` to reduce transaction count when using funding admins
     *@param _amount Number of tokens to transfer
     */
    function add_tokens(uint256 _amount) external {
        require(msg.sender == admin, "dev admin only"); // dev admin only
        IERC20(token).safeTransferFrom(msg.sender, address(this), _amount);
        unallocated_supply += _amount;
    }

    /***
     *@notice Vest tokens for multiple recipients.
     *@param _recipients List of addresses to fund
     *@param _amounts Amount of vested tokens for each address
     */
    function fund(address[100] memory _recipients, uint256[100] memory _amounts) external nonReentrant {
        if (msg.sender != admin) {
            require(fund_admins[msg.sender], "dev admin only");
            require(fund_admins_enabled, "dev fund admins disabled");
        }

        uint256 _total_amount = 0;
        for (uint256 i; i < 100; i++) {
            uint256 amount = _amounts[i];
            address recipient = _recipients[i];
            if (recipient == address(0)) {
                break;
            }
            _total_amount += amount;
            initial_locked[recipient] += amount;
            emit Fund(recipient, amount);
        }

        initial_locked_supply += _total_amount;
        unallocated_supply -= _total_amount;
    }

    /***
     *@notice Disable further flow of tokens and clawback the unvested part to admin
     */
    function rug_pull(address _target) external {

        require(msg.sender == admin, "onlyOwner");

        uint256 raggable = initial_locked[_target] - _total_vested_of(_target, block.timestamp); //all unvested token

        is_ragged[_target] = true;
        disabled_at[_target] = block.timestamp; //never be updated later on.

        rugged_amount += raggable;

        require(IERC20(token).transfer(admin, raggable));

        emit RugPull(admin, raggable);
    }

    /***
     *@notice Disable or re-enable a vested address's ability to claim tokens
     *@dev When disabled, the address is only unable to claim tokens which are still
     *    locked at the time of this call. It is not possible to block the claim
     *    of tokens which have already vested.
     *@param _recipient Address to disable or enable
     */
    function toggle_disable(address _recipient) external {
        require(msg.sender == admin, "onlyOwner");
        require(can_disable, "Cannot disable");
        require(!is_ragged[_recipient], "is rugged");

        bool is_disabled = disabled_at[_recipient] == 0;
        if (is_disabled) {
            disabled_at[_recipient] = block.timestamp;
        } else {
            disabled_at[_recipient] = 0;
        }

        emit ToggleDisable(_recipient, is_disabled);
    }

    /***
     *@notice Disable the ability to call `toggle_disable`
     */
    function disable_can_disable() external {

        require(msg.sender == admin, "dev admin only");
        can_disable = false;
    }

    /***
     *@notice Disable the funding admin accounts
     */
    function disable_fund_admins() external {
        require(msg.sender == admin, "dev admin only");
        fund_admins_enabled = false;
    }

    /***
     * @notice Amount of unlocked token amount of _recipient at _time. (include claimed)
     */
    function _total_vested_of(address _recipient, uint256 _time) internal view returns(uint256) {

        uint256 start = start_time;
        uint256 end = end_time;
        uint256 locked = initial_locked[_recipient];
        if (_time < start) {
            return 0;
        }
        return min(locked * (_time - start) / (end - start), locked);
    }

    function _total_vested() internal view returns(uint256) {
        uint256 start = start_time;
        uint256 end = end_time;
        uint256 locked = initial_locked_supply;

        if (block.timestamp < start) {
            return 0;
        } else {
            return min(locked * (block.timestamp - start) / (end - start), locked); // when block.timestamp > end, return locked
        }
    }

    /***
     *@notice Get the total number of tokens which have vested, that are held
     *        by this contract
     */
    function vestedSupply() external view returns(uint256) {
        return _total_vested();
    }

    /***
     *@notice Get the total number of tokens which are still locked
     *        (have not yet vested)
     */
    function lockedSupply() external view returns(uint256) {
        return initial_locked_supply - _total_vested();
    }

    /***
     *@notice Get the number of tokens which have vested for a given address
     *@param _recipient address to check
     */
    function vestedOf(address _recipient) external view returns(uint256) {
        uint256 t = disabled_at[_recipient];
        if (t == 0) {
            t = block.timestamp;
        }

        return _total_vested_of(_recipient, t);
    }

    /***
     *@notice Get the number of unclaimed, vested tokens for a given address
     *@param _recipient address to check
     */
    function balanceOf(address _recipient) external view returns(uint256) {
        uint256 t = disabled_at[_recipient];
        if (t == 0) {
            t = block.timestamp;
        }

        return _total_vested_of(_recipient, t) - total_claimed[_recipient];
    }

    /***
     *@notice Get the number of locked tokens for a given address
     *@param _recipient address to check
     */
    function lockedOf(address _recipient) external view returns(uint256) {
        if (is_ragged[_recipient] == true) {
            return 0;
        } else {
            return initial_locked[_recipient] - _total_vested_of(_recipient, block.timestamp);
        }
    }

    /***
     *@notice Claim tokens which have vested
     *@param addr Address to claim tokens for
     */
    function claim(address addr) external nonReentrant {
        uint256 t = disabled_at[addr];
        if (t == 0) {
            t = block.timestamp;
        }
        uint256 claimable = _total_vested_of(addr, t) - total_claimed[addr];

        total_claimed[addr] += claimable;
        require(IERC20(token).transfer(addr, claimable));

        emit Claim(addr, claimable);
    }

    /***
     *@notice Transfer ownership of GaugeController to `addr`
     *@param addr Address to have ownership transferred to
     */
    function commit_transfer_ownership(address addr) external returns(bool) {
        require(msg.sender == admin, "onlyOwner");
        future_admin = addr;
        emit CommitOwnership(addr);

        return true;
    }

    /***
     *@notice Accept a transfer of ownership
     *@return bool success
     */
    function accept_transfer_ownership() external {
        address _future_admin = future_admin;
        require(address(msg.sender) == _future_admin, "onlyFutureOwner");
        admin = _future_admin;
        emit AcceptOwnership(_future_admin);
    }

    function min(uint256 a, uint256 b) internal pure returns(uint256) {
        return a < b ? a : b;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_start_time","type":"uint256"},{"internalType":"uint256","name":"_end_time","type":"uint256"},{"internalType":"bool","name":"_can_disable","type":"bool"},{"internalType":"address[4]","name":"_fund_admins","type":"address[4]"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"admin","type":"address"}],"name":"AcceptOwnership","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"claimed","type":"uint256"}],"name":"Claim","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"admin","type":"address"}],"name":"CommitOwnership","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Fund","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"rugged","type":"uint256"}],"name":"RugPull","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"bool","name":"disabled","type":"bool"}],"name":"ToggleDisable","type":"event"},{"inputs":[],"name":"accept_transfer_ownership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"add_tokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"can_disable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"commit_transfer_ownership","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"disable_can_disable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"disable_fund_admins","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"disabled_at","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"end_time","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[100]","name":"_recipients","type":"address[100]"},{"internalType":"uint256[100]","name":"_amounts","type":"uint256[100]"}],"name":"fund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"fund_admins","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fund_admins_enabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"future_admin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"initial_locked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initial_locked_supply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"is_ragged","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"}],"name":"lockedOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockedSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_target","type":"address"}],"name":"rug_pull","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rugged_amount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"start_time","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"}],"name":"toggle_disable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"total_claimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unallocated_supply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"}],"name":"vestedOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vestedSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

18169:9762:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18976:23;;;;;;;;;;;;179:14:1;;172:22;154:41;;142:2;127:18;18976:23:0;;;;;;;;18899:33;;;;;;;;;352:25:1;;;340:2;325:18;18899:33:0;206:177:1;19124:31:0;;;;;-1:-1:-1;;;19124:31:0;;;;;;18665:23;;;;;;19162:43;;;;;;:::i;:::-;;;;;;;;;;;;;;;;19088:27;;;;;-1:-1:-1;;;;;19088:27:0;;;;;;-1:-1:-1;;;;;921:32:1;;;903:51;;891:2;876:18;19088:27:0;757:203:1;26698:389:0;;;;;;:::i;:::-;;:::i;:::-;;18856:36;;;;;;18806:41;;;;;;:::i;:::-;;;;;;;;;;;;;;;;23627:137;;;:::i;23052:488::-;;;;;;:::i;:::-;;:::i;18695:49::-;;;;;;:::i;:::-;;;;;;;;;;;;;;19006:46;;;;;;:::i;:::-;;;;;;;;;;;;;;27237:223;;;;;;:::i;:::-;;:::i;25900:271::-;;;;;;:::i;:::-;;:::i;23841:143::-;;;:::i;18939:28::-;;;;;;18633:25;;;;;;25511:242;;;;;;:::i;:::-;;:::i;26307:271::-;;;;;;:::i;:::-;;:::i;18751:48::-;;;;;;:::i;:::-;;;;;;;;;;;;;;25244:120;;;:::i;20855:246::-;;;;;;:::i;:::-;;:::i;25015:96::-;;;:::i;21296:783::-;;;;;;:::i;:::-;;:::i;27561:254::-;;;:::i;22192:484::-;;;;;;:::i;:::-;;:::i;19061:20::-;;;;;-1:-1:-1;;;;;19061:20:0;;;18585;;;;;-1:-1:-1;;;;;18585:20:0;;;26698:389;16944:1;17542:7;;:19;;17534:63;;;;-1:-1:-1;;;17534:63:0;;2826:2:1;17534:63:0;;;2808:21:1;2865:2;2845:18;;;2838:30;2904:33;2884:18;;;2877:61;2955:18;;17534:63:0;;;;;;;;;16944:1;17675:7;:18;;;-1:-1:-1;;;;;26772:17:0;::::1;::::0;;:11:::1;:17;::::0;;;;;26804:6;26800:58:::1;;-1:-1:-1::0;26831:15:0::1;26800:58;-1:-1:-1::0;;;;;26916:19:0;::::1;26868:17;26916:19:::0;;;:13:::1;:19;::::0;;;;;26888:25:::1;26930:4:::0;26911:1;26888:16:::1;:25::i;:::-;:47;;;;:::i;:::-;-1:-1:-1::0;;;;;26948:19:0;::::1;;::::0;;;:13:::1;:19;::::0;;;;:32;;26868:67;;-1:-1:-1;26868:67:0;;26948:19;;;:32:::1;::::0;26868:67;;26948:32:::1;:::i;:::-;::::0;;;-1:-1:-1;;27006:5:0::1;::::0;26999:39:::1;::::0;-1:-1:-1;;;26999:39:0;;-1:-1:-1;;;;;3571:32:1;;;26999:39:0::1;::::0;::::1;3553:51:1::0;3620:18;;;3613:34;;;27006:5:0;;::::1;::::0;26999:22:::1;::::0;3526:18:1;;26999:39:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;26991:48;;;::::0;::::1;;27063:4;-1:-1:-1::0;;;;;27057:22:0::1;;27069:9;27057:22;;;;352:25:1::0;;340:2;325:18;;206:177;27057:22:0::1;;;;;;;;-1:-1:-1::0;;16900:1:0;17854:7;:22;-1:-1:-1;26698:389:0:o;23627:137::-;23702:5;;-1:-1:-1;;;;;23702:5:0;23688:10;:19;23680:46;;;;-1:-1:-1;;;23680:46:0;;;;;;;:::i;:::-;23737:11;:19;;-1:-1:-1;;23737:19:0;;;23627:137::o;23052:488::-;23138:5;;-1:-1:-1;;;;;23138:5:0;23124:10;:19;23116:41;;;;-1:-1:-1;;;23116:41:0;;;;;;;:::i;:::-;23176:11;;;;23168:38;;;;-1:-1:-1;;;23168:38:0;;4822:2:1;23168:38:0;;;4804:21:1;4861:2;4841:18;;;4834:30;-1:-1:-1;;;4880:18:1;;;4873:44;4934:18;;23168:38:0;4620:338:1;23168:38:0;-1:-1:-1;;;;;23226:21:0;;;;;;:9;:21;;;;;;;;23225:22;23217:44;;;;-1:-1:-1;;;23217:44:0;;5165:2:1;23217:44:0;;;5147:21:1;5204:1;5184:18;;;5177:29;-1:-1:-1;;;5222:18:1;;;5215:39;5271:18;;23217:44:0;4963:332:1;23217:44:0;-1:-1:-1;;;;;23293:23:0;;23274:16;23293:23;;;:11;:23;;;;;;:28;23332:145;;;;-1:-1:-1;;;;;23364:23:0;;;;;;:11;:23;;;;;23390:15;23364:41;;23332:145;;;-1:-1:-1;;;;;23438:23:0;;23464:1;23438:23;;;:11;:23;;;;;:27;23332:145;23494:38;;;-1:-1:-1;;;;;5486:32:1;;5468:51;;5562:14;;5555:22;5550:2;5535:18;;5528:50;23494:38:0;;5441:18:1;23494:38:0;;;;;;;;23105:435;23052:488;:::o;27237:223::-;27342:5;;27303:4;;-1:-1:-1;;;;;27342:5:0;27328:10;:19;27320:41;;;;-1:-1:-1;;;27320:41:0;;;;;;;:::i;:::-;27372:12;:19;;-1:-1:-1;;;;;;27372:19:0;-1:-1:-1;;;;;27372:19:0;;;;;;;;27407:21;;903:51:1;;;27407:21:0;;891:2:1;876:18;27407:21:0;;;;;;;-1:-1:-1;27448:4:0;;27237:223;-1:-1:-1;27237:223:0:o;25900:271::-;-1:-1:-1;;;;;25993:23:0;;25961:7;25993:23;;;:11;:23;;;;;;26031:6;26027:58;;-1:-1:-1;26058:15:0;26027:58;-1:-1:-1;;;;;26138:25:0;;;;;;:13;:25;;;;;;26104:31;26152:10;26133:1;26104:16;:31::i;:::-;:59;;;;:::i;:::-;26097:66;25900:271;-1:-1:-1;;;25900:271:0:o;23841:143::-;23914:5;;-1:-1:-1;;;;;23914:5:0;23900:10;:19;23892:46;;;;-1:-1:-1;;;23892:46:0;;;;;;;:::i;:::-;23949:19;:27;;-1:-1:-1;;;;23949:27:0;;;23841:143::o;25511:242::-;-1:-1:-1;;;;;25603:23:0;;25571:7;25603:23;;;:11;:23;;;;;;25641:6;25637:58;;-1:-1:-1;25668:15:0;25637:58;25714:31;25731:10;25743:1;25714:16;:31::i;26307:271::-;-1:-1:-1;;;;;26391:21:0;;26367:7;26391:21;;;:9;:21;;;;;;;;:29;;:21;:29;26387:184;;;-1:-1:-1;26444:1:0;;26307:271;-1:-1:-1;26307:271:0:o;26387:184::-;26514:45;26531:10;26543:15;26514:16;:45::i;:::-;-1:-1:-1;;;;;26485:26:0;;;;;;:14;:26;;;;;;:74;;;;:::i;:::-;26478:81;26307:271;-1:-1:-1;;26307:271:0:o;26387:184::-;26307:271;;;:::o;25244:120::-;25290:7;25341:15;:13;:15::i;:::-;25317:21;;:39;;;;:::i;:::-;25310:46;;25244:120;:::o;20855:246::-;20934:5;;-1:-1:-1;;;;;20934:5:0;20920:10;:19;20912:46;;;;-1:-1:-1;;;20912:46:0;;;;;;;:::i;:::-;20994:5;;20987:66;;-1:-1:-1;;;;;20994:5:0;21018:10;21038:4;21045:7;20987:30;:66::i;:::-;21086:7;21064:18;;:29;;;;;;;:::i;:::-;;;;-1:-1:-1;;;20855:246:0:o;25015:96::-;25061:7;25088:15;:13;:15::i;21296:783::-;16944:1;17542:7;;:19;;17534:63;;;;-1:-1:-1;;;17534:63:0;;2826:2:1;17534:63:0;;;2808:21:1;2865:2;2845:18;;;2838:30;2904:33;2884:18;;;2877:61;2955:18;;17534:63:0;2624:355:1;17534:63:0;16944:1;17675:7;:18;21424:5:::1;::::0;-1:-1:-1;;;;;21424:5:0::1;21410:10;:19;21406:173;;21466:10;21454:23;::::0;;;:11:::1;:23;::::0;;;;;::::1;;21446:50;;;;-1:-1:-1::0;;;21446:50:0::1;;;;;;;:::i;:::-;21519:19;::::0;-1:-1:-1;;;21519:19:0;::::1;;;21511:56;;;::::0;-1:-1:-1;;;21511:56:0;;5791:2:1;21511:56:0::1;::::0;::::1;5773:21:1::0;5830:2;5810:18;;;5803:30;5869:26;5849:18;;;5842:54;5913:18;;21511:56:0::1;5589:348:1::0;21511:56:0::1;21591:21;21632:9:::0;21627:348:::1;21647:3;21643:1;:7;21627:348;;;21672:14;21689:8;21698:1;21689:11;;;;;;;:::i;:::-;;;;;21672:28;;21715:17;21735:11;21747:1;21735:14;;;;;;;:::i;:::-;;;;::::0;;-1:-1:-1;;;;;;21768:23:0;::::1;21764:69;;21812:5;;;;21764:69;21847:23;21864:6:::0;21847:23;::::1;:::i;:::-;-1:-1:-1::0;;;;;21885:25:0;::::1;;::::0;;;:14:::1;:25;::::0;;;;:35;;21847:23;;-1:-1:-1;21914:6:0;;21885:25;;;:35:::1;::::0;21914:6;;21885:35:::1;:::i;:::-;::::0;;;-1:-1:-1;;21940:23:0::1;::::0;352:25:1;;;-1:-1:-1;;;;;21940:23:0;::::1;::::0;::::1;::::0;340:2:1;325:18;21940:23:0::1;;;;;;;21657:318;;21652:3;;;;;:::i;:::-;;;;21627:348;;;;22012:13;21987:21;;:38;;;;;;;:::i;:::-;;;;;;;;22058:13;22036:18;;:35;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;16900:1:0;17854:7;:22;-1:-1:-1;;;21296:783:0:o;27561:254::-;27642:12;;-1:-1:-1;;;;;27642:12:0;27681:10;27673:36;;27665:64;;;;-1:-1:-1;;;27665:64:0;;6416:2:1;27665:64:0;;;6398:21:1;6455:2;6435:18;;;6428:30;-1:-1:-1;;;6474:18:1;;;6467:45;6529:18;;27665:64:0;6214:339:1;27665:64:0;27740:5;:21;;-1:-1:-1;;;;;;27740:21:0;-1:-1:-1;;;;;27740:21:0;;;;;;;;27777:30;;903:51:1;;;27777:30:0;;891:2:1;876:18;27777:30:0;;;;;;;27607:208;27561:254::o;22192:484::-;22271:5;;-1:-1:-1;;;;;22271:5:0;22257:10;:19;22249:41;;;;-1:-1:-1;;;22249:41:0;;;;;;;:::i;:::-;22303:16;22348:42;22365:7;22374:15;22348:16;:42::i;:::-;-1:-1:-1;;;;;22322:23:0;;;;;;:14;:23;;;;;;:68;;;;:::i;:::-;-1:-1:-1;;;;;22424:18:0;;;;;;:9;:18;;;;;;;;:25;;-1:-1:-1;;22424:25:0;22445:4;22424:25;;;22460:11;:20;;;;;22483:15;22460:38;;22540:13;:25;;22303:87;;-1:-1:-1;22303:87:0;;22540:13;;22424:18;22540:25;;22303:87;;22540:25;:::i;:::-;;;;-1:-1:-1;;22593:5:0;;22609;;22586:39;;-1:-1:-1;;;22586:39:0;;-1:-1:-1;;;;;22609:5:0;;;22586:39;;;3553:51:1;3620:18;;;3613:34;;;22593:5:0;;;22586:22;;3526:18:1;;22586:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;22578:48;;;;;;22652:5;;22644:24;;;-1:-1:-1;;;;;22652:5:0;;;3553:51:1;;3635:2;3620:18;;3613:34;;;22644:24:0;;3526:18:1;22644:24:0;3379:274:1;24101:361:0;24222:10;;24257:8;;-1:-1:-1;;;;;24293:26:0;;24184:7;24293:26;;;:14;:26;;;;;;24184:7;;24222:10;24257:8;24334:13;;;24330:54;;;24371:1;24364:8;;;;;;;24330:54;24401:53;24433:11;24439:5;24433:3;:11;:::i;:::-;24415:13;24423:5;24415;:13;:::i;:::-;24405:24;;:6;:24;:::i;:::-;:40;;;;:::i;:::-;24447:6;24401:3;:53::i;:::-;24394:60;24101:361;-1:-1:-1;;;;;;24101:361:0:o;24470:407::-;24553:10;;24588:8;;24624:21;;24517:7;;24553:10;24588:8;24662:15;:23;-1:-1:-1;24658:212:0;;;24709:1;24702:8;;;;;24470:407;:::o;24658:212::-;24750:63;24792:11;24798:5;24792:3;:11;:::i;:::-;24764:23;24782:5;24764:15;:23;:::i;24750:63::-;24743:70;;;;;24470:407;:::o;12047:248::-;12218:68;;;-1:-1:-1;;;;;7211:15:1;;;12218:68:0;;;7193:34:1;7263:15;;7243:18;;;7236:43;7295:18;;;;7288:34;;;12218:68:0;;;;;;;;;;7128:18:1;;;;12218:68:0;;;;;;;;-1:-1:-1;;;;;12218:68:0;-1:-1:-1;;;12218:68:0;;;12191:96;;12211:5;;12191:19;:96::i;:::-;12047:248;;;;:::o;27823:105::-;27880:7;27911:1;27907;:5;:13;;27919:1;27907:13;;;-1:-1:-1;27915:1:0;;27900:20;-1:-1:-1;27823:105:0:o;14401:716::-;14825:23;14851:69;14879:4;14851:69;;;;;;;;;;;;;;;;;14859:5;-1:-1:-1;;;;;14851:27:0;;;:69;;;;;:::i;:::-;14935:17;;14825:95;;-1:-1:-1;14935:21:0;14931:179;;15032:10;15021:30;;;;;;;;;;;;:::i;:::-;15013:85;;;;-1:-1:-1;;;15013:85:0;;7535:2:1;15013:85:0;;;7517:21:1;7574:2;7554:18;;;7547:30;7613:34;7593:18;;;7586:62;-1:-1:-1;;;7664:18:1;;;7657:40;7714:19;;15013:85:0;7333:406:1;15013:85:0;14471:646;14401:716;;:::o;6600:229::-;6737:12;6769:52;6791:6;6799:4;6805:1;6808:12;6769:21;:52::i;:::-;6762:59;6600:229;-1:-1:-1;;;;6600:229:0:o;7720:510::-;7890:12;7948:5;7923:21;:30;;7915:81;;;;-1:-1:-1;;;7915:81:0;;7946:2:1;7915:81:0;;;7928:21:1;7985:2;7965:18;;;7958:30;8024:34;8004:18;;;7997:62;-1:-1:-1;;;8075:18:1;;;8068:36;8121:19;;7915:81:0;7744:402:1;7915:81:0;4117:20;;8007:60;;;;-1:-1:-1;;;8007:60:0;;8353:2:1;8007:60:0;;;8335:21:1;8392:2;8372:18;;;8365:30;8431:31;8411:18;;;8404:59;8480:18;;8007:60:0;8151:353:1;8007:60:0;8081:12;8095:23;8122:6;-1:-1:-1;;;;;8122:11:0;8141:5;8148:4;8122:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8080:73;;;;8171:51;8188:7;8197:10;8209:12;8171:16;:51::i;:::-;8164:58;7720:510;-1:-1:-1;;;;;;;7720:510:0:o;10406:712::-;10556:12;10585:7;10581:530;;;-1:-1:-1;10616:10:0;10609:17;;10581:530;10730:17;;:21;10726:374;;10928:10;10922:17;10989:15;10976:10;10972:2;10968:19;10961:44;10726:374;11071:12;11064:20;;-1:-1:-1;;;11064:20:0;;;;;;;;:::i;388:173:1:-;456:20;;-1:-1:-1;;;;;505:31:1;;495:42;;485:70;;551:1;548;541:12;566:186;625:6;678:2;666:9;657:7;653:23;649:32;646:52;;;694:1;691;684:12;646:52;717:29;736:9;717:29;:::i;965:180::-;1024:6;1077:2;1065:9;1056:7;1052:23;1048:32;1045:52;;;1093:1;1090;1083:12;1045:52;-1:-1:-1;1116:23:1;;965:180;-1:-1:-1;965:180:1:o;1150:345::-;1217:2;1211:9;1259:4;1247:17;;1294:18;1279:34;;1315:22;;;1276:62;1273:185;;;1380:10;1375:3;1371:20;1368:1;1361:31;1415:4;1412:1;1405:15;1443:4;1440:1;1433:15;1273:185;1474:2;1467:22;1150:345;:::o;1500:1119::-;1618:6;1626;1657:4;1702:2;1690:9;1681:7;1677:23;1673:32;1670:52;;;1718:1;1715;1708:12;1670:52;1767:7;1760:4;1749:9;1745:20;1741:34;1731:62;;1789:1;1786;1779:12;1731:62;1813:17;;:::i;:::-;1852:3;1893:4;1882:9;1878:20;1921:7;1913:6;1910:19;1907:39;;;1942:1;1939;1932:12;1907:39;1966:9;1984:152;2000:6;1995:3;1992:15;1984:152;;;2068:23;2087:3;2068:23;:::i;:::-;2056:36;;2121:4;2112:14;;;;2017;1984:152;;;1988:3;2155:5;2145:15;;2205:7;2198:4;2187:9;2183:20;2179:34;2169:62;;2227:1;2224;2217:12;2169:62;2253:17;;:::i;:::-;2322:18;;;;2240:30;-1:-1:-1;2240:30:1;;-1:-1:-1;2352:21:1;;;2349:41;;;2386:1;2383;2376:12;2349:41;2427:162;2445:8;2438:5;2435:19;2427:162;;;2521:19;;2507:34;;2574:4;2563:16;;;;2466;2427:162;;;2431:3;2608:5;2598:15;;;;;1500:1119;;;;;:::o;2984:127::-;3045:10;3040:3;3036:20;3033:1;3026:31;3076:4;3073:1;3066:15;3100:4;3097:1;3090:15;3116:125;3156:4;3184:1;3181;3178:8;3175:34;;;3189:18;;:::i;:::-;-1:-1:-1;3226:9:1;;3116:125::o;3246:128::-;3286:3;3317:1;3313:6;3310:1;3307:13;3304:39;;;3323:18;;:::i;:::-;-1:-1:-1;3359:9:1;;3246:128::o;3658:277::-;3725:6;3778:2;3766:9;3757:7;3753:23;3749:32;3746:52;;;3794:1;3791;3784:12;3746:52;3826:9;3820:16;3879:5;3872:13;3865:21;3858:5;3855:32;3845:60;;3901:1;3898;3891:12;3940:338;4142:2;4124:21;;;4181:2;4161:18;;;4154:30;-1:-1:-1;;;4215:2:1;4200:18;;4193:44;4269:2;4254:18;;3940:338::o;4283:332::-;4485:2;4467:21;;;4524:1;4504:18;;;4497:29;-1:-1:-1;;;4557:2:1;4542:18;;4535:39;4606:2;4591:18;;4283:332::o;5942:127::-;6003:10;5998:3;5994:20;5991:1;5984:31;6034:4;6031:1;6024:15;6058:4;6055:1;6048:15;6074:135;6113:3;-1:-1:-1;;6134:17:1;;6131:43;;;6154:18;;:::i;:::-;-1:-1:-1;6201:1:1;6190:13;;6074:135::o;6558:168::-;6598:7;6664:1;6660;6656:6;6652:14;6649:1;6646:21;6641:1;6634:9;6627:17;6623:45;6620:71;;;6671:18;;:::i;:::-;-1:-1:-1;6711:9:1;;6558:168::o;6731:217::-;6771:1;6797;6787:132;;6841:10;6836:3;6832:20;6829:1;6822:31;6876:4;6873:1;6866:15;6904:4;6901:1;6894:15;6787:132;-1:-1:-1;6933:9:1;;6731:217::o;8509:258::-;8581:1;8591:113;8605:6;8602:1;8599:13;8591:113;;;8681:11;;;8675:18;8662:11;;;8655:39;8627:2;8620:10;8591:113;;;8722:6;8719:1;8716:13;8713:48;;;-1:-1:-1;;8757:1:1;8739:16;;8732:27;8509:258::o;8772:274::-;8901:3;8939:6;8933:13;8955:53;9001:6;8996:3;8989:4;8981:6;8977:17;8955:53;:::i;:::-;9024:16;;;;;8772:274;-1:-1:-1;;8772:274:1:o;9051:383::-;9200:2;9189:9;9182:21;9163:4;9232:6;9226:13;9275:6;9270:2;9259:9;9255:18;9248:34;9291:66;9350:6;9345:2;9334:9;9330:18;9325:2;9317:6;9313:15;9291:66;:::i;:::-;9418:2;9397:15;-1:-1:-1;;9393:29:1;9378:45;;;;9425:2;9374:54;;9051:383;-1:-1:-1;;9051:383:1:o

ipfs://fe083830fe515a23932f8786fb96532e728f6a9e3c92ca527764bf8cdb5b6414