Contract 0x9dab4c93a676beb77623e5f15579ad9edbdcc053

/**
 *Submitted for verification at celoscan.io on 2022-11-08
*/

// Sources flattened with hardhat v2.9.3 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/cryptography/[email protected]

// OpenZeppelin Contracts v4.4.1 (utils/cryptography/MerkleProof.sol)


/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merklee tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];
            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }
        return computedHash;
    }
}


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

// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)


/**
 * @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) {
        return msg.data;
    }
}


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

// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)


/**
 * @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() {
        _transferOwnership(_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 {
        _transferOwnership(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");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


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

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}


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

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




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - amount);
        }

        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}


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

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


/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}


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

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/ERC20Pausable.sol)



/**
 * @dev ERC20 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 */
abstract contract ERC20Pausable is ERC20, Pausable {
    /**
     * @dev See {ERC20-_beforeTokenTransfer}.
     *
     * Requirements:
     *
     * - the contract must not be paused.
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, amount);

        require(!paused(), "ERC20Pausable: token transfer while paused");
    }
}


// File contracts/MooCompensationDistributor.sol





contract MooCompensationDistributor is Ownable {
    uint public immutable timeout;
    uint public immutable startTime;
    address public immutable token;
    bytes32 public merkleRoot;

    // This is a packed array of booleans.
    mapping(address => uint256) public claimedAmount;

    event Claimed(uint256 index, address account, uint256 amount);
    event RootUpdated(bytes32 newRoot);

    constructor(address token_, bytes32 merkleRoot_, address owner_, uint timeout_, uint startTime_) {
        transferOwnership(owner_);
        token = token_;
        merkleRoot = merkleRoot_;
        timeout = timeout_;
        startTime = startTime_;
    }

    function claim(uint256 index, address account, uint256 amount, bytes32[] calldata merkleProof) external claimStarted {
        uint claimed = claimedAmount[account];
        require(claimed < amount, 'AccumulatingMerkleDistributor: Drop already claimed.');

        // Verify the merkle proof.
        bytes32 node = keccak256(abi.encodePacked(index, account, amount));
        require(MerkleProof.verify(merkleProof, merkleRoot, node), 'AccumulatingMerkleDistributor: Invalid proof.');

        // Mark it claimed and send the token.
        claimedAmount[account] = amount;
        require(IERC20(token).transfer(account, amount - claimed), 'AccumulatingMerkleDistributor: Transfer failed.');

        emit Claimed(index, account, amount);
    }

    // New root should include all old recipients plus new ones.
    function updateRoot(bytes32 newRoot) public onlyOwner() {
        merkleRoot = newRoot;
        emit RootUpdated(newRoot);
    }

    function recover(address to, bytes calldata data) external onlyOwner() returns(bool, bytes memory) {
        if (to == token) {
            require(block.timestamp > timeout, 'AccumulatingMerkleDistributor: not timed out yet.');
        }
        return to.call(data);
    }

    modifier claimStarted() {
        require(block.timestamp > startTime, 'Claiming has not started yet.');
        _;
    }
}

[{"inputs":[{"internalType":"address","name":"token_","type":"address"},{"internalType":"bytes32","name":"merkleRoot_","type":"bytes32"},{"internalType":"address","name":"owner_","type":"address"},{"internalType":"uint256","name":"timeout_","type":"uint256"},{"internalType":"uint256","name":"startTime_","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claimed","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":false,"internalType":"bytes32","name":"newRoot","type":"bytes32"}],"name":"RootUpdated","type":"event"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"claimedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"recover","outputs":[{"internalType":"bool","name":"","type":"bool"},{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"timeout","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"newRoot","type":"bytes32"}],"name":"updateRoot","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000017700282592d6917f6a73d0bf8accf4d578c131e498e7672b5c20d6693cb76dfa467421f788e0821a4c02f39a207d0ec708b2a1b0000000000000000000000003b0b4c9928c1412fbb69e2bdd50d6b7b98398d960000000000000000000000000000000000000000000000000000000065d1569000000000000000000000000000000000000000000000000000000000652f2000

-----Decoded View---------------
Arg [0] : token_ (address): 0x17700282592d6917f6a73d0bf8accf4d578c131e
Arg [1] : merkleRoot_ (bytes32): 0x498e7672b5c20d6693cb76dfa467421f788e0821a4c02f39a207d0ec708b2a1b
Arg [2] : owner_ (address): 0x3b0b4c9928c1412fbb69e2bdd50d6b7b98398d96
Arg [3] : timeout_ (uint256): 1708218000
Arg [4] : startTime_ (uint256): 1697587200

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 00000000000000000000000017700282592d6917f6a73d0bf8accf4d578c131e
Arg [1] : 498e7672b5c20d6693cb76dfa467421f788e0821a4c02f39a207d0ec708b2a1b
Arg [2] : 0000000000000000000000003b0b4c9928c1412fbb69e2bdd50d6b7b98398d96
Arg [3] : 0000000000000000000000000000000000000000000000000000000065d15690
Arg [4] : 00000000000000000000000000000000000000000000000000000000652f2000

24566:2069:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24809:48;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26082:131;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;25248:760;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;24731:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26221:279;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;24620:29;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7677:103;;;:::i;:::-;;24656:31;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7026:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7935:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;24694:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;24809:48;;;;;;;;;;;;;;;;;:::o;26082:131::-;7257:12;:10;:12::i;:::-;7246:23;;:7;:5;:7::i;:::-;:23;;;7238:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;26162:7:::1;26149:10;:20;;;;26185;26197:7;26185:20;;;;;;:::i;:::-;;;;;;;;26082:131:::0;:::o;25248:760::-;26569:9;26551:15;:27;26543:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;25376:12:::1;25391:13;:22;25405:7;25391:22;;;;;;;;;;;;;;;;25376:37;;25442:6;25432:7;:16;25424:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;25555:12;25597:5;25604:7;25613:6;25580:40;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;25570:51;;;;;;25555:66;;25640:49;25659:11;;25640:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25672:10;;25684:4;25640:18;:49::i;:::-;25632:107;;;;;;;;;;;;:::i;:::-;;;;;;;;;25825:6;25800:13;:22;25814:7;25800:22;;;;;;;;;;;;;;;:31;;;;25857:5;25850:22;;;25873:7;25891;25882:6;:16;;;;:::i;:::-;25850:49;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;25842:109;;;;;;;;;;;;:::i;:::-;;;;;;;;;25969:31;25977:5;25984:7;25993:6;25969:31;;;;;;;;:::i;:::-;;;;;;;;25365:643;;25248:760:::0;;;;;:::o;24731:25::-;;;;:::o;26221:279::-;26300:4;26306:12;7257;:10;:12::i;:::-;7246:23;;:7;:5;:7::i;:::-;:23;;;7238:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;26341:5:::1;26335:11;;:2;:11;;;26331:131;;;26389:7;26371:15;:25;26363:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;26331:131;26479:2;:7;;26487:4;;26479:13;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26472:20;;;;26221:279:::0;;;;;;:::o;24620:29::-;;;:::o;7677:103::-;7257:12;:10;:12::i;:::-;7246:23;;:7;:5;:7::i;:::-;:23;;;7238:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;7742:30:::1;7769:1;7742:18;:30::i;:::-;7677:103::o:0;24656:31::-;;;:::o;7026:87::-;7072:7;7099:6;;;;;;;;;;;7092:13;;7026:87;:::o;7935:201::-;7257:12;:10;:12::i;:::-;7246:23;;:7;:5;:7::i;:::-;:23;;;7238:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;8044:1:::1;8024:22;;:8;:22;;;;8016:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;8100:28;8119:8;8100:18;:28::i;:::-;7935:201:::0;:::o;24694:30::-;;;:::o;5771:98::-;5824:7;5851:10;5844:17;;5771:98;:::o;3851:190::-;3976:4;4029;4000:25;4013:5;4020:4;4000:12;:25::i;:::-;:33;3993:40;;3851:190;;;;;:::o;8296:191::-;8370:16;8389:6;;;;;;;;;;;8370:25;;8415:8;8406:6;;:17;;;;;;;;;;;;;;;;;;8470:8;8439:40;;8460:8;8439:40;;;;;;;;;;;;8359:128;8296:191;:::o;4403:701::-;4486:7;4506:20;4529:4;4506:27;;4549:9;4544:523;4568:5;:12;4564:1;:16;4544:523;;;4602:20;4625:5;4631:1;4625:8;;;;;;;;:::i;:::-;;;;;;;;4602:31;;4668:12;4652;:28;4648:408;;4822:12;4836;4805:44;;;;;;;;;:::i;:::-;;;;;;;;;;;;;4795:55;;;;;;4780:70;;4648:408;;;5012:12;5026;4995:44;;;;;;;;;:::i;:::-;;;;;;;;;;;;;4985:55;;;;;;4970:70;;4648:408;4587:480;4582:3;;;;;:::i;:::-;;;;4544:523;;;;5084:12;5077:19;;;4403:701;;;;:::o;88:117:1:-;197:1;194;187:12;211:117;320:1;317;310:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:329::-;900:6;949:2;937:9;928:7;924:23;920:32;917:119;;;955:79;;:::i;:::-;917:119;1075:1;1100:53;1145:7;1136:6;1125:9;1121:22;1100:53;:::i;:::-;1090:63;;1046:117;841:329;;;;:::o;1176:77::-;1213:7;1242:5;1231:16;;1176:77;;;:::o;1259:118::-;1346:24;1364:5;1346:24;:::i;:::-;1341:3;1334:37;1259:118;;:::o;1383:222::-;1476:4;1514:2;1503:9;1499:18;1491:26;;1527:71;1595:1;1584:9;1580:17;1571:6;1527:71;:::i;:::-;1383:222;;;;:::o;1611:77::-;1648:7;1677:5;1666:16;;1611:77;;;:::o;1694:122::-;1767:24;1785:5;1767:24;:::i;:::-;1760:5;1757:35;1747:63;;1806:1;1803;1796:12;1747:63;1694:122;:::o;1822:139::-;1868:5;1906:6;1893:20;1884:29;;1922:33;1949:5;1922:33;:::i;:::-;1822:139;;;;:::o;1967:329::-;2026:6;2075:2;2063:9;2054:7;2050:23;2046:32;2043:119;;;2081:79;;:::i;:::-;2043:119;2201:1;2226:53;2271:7;2262:6;2251:9;2247:22;2226:53;:::i;:::-;2216:63;;2172:117;1967:329;;;;:::o;2302:122::-;2375:24;2393:5;2375:24;:::i;:::-;2368:5;2365:35;2355:63;;2414:1;2411;2404:12;2355:63;2302:122;:::o;2430:139::-;2476:5;2514:6;2501:20;2492:29;;2530:33;2557:5;2530:33;:::i;:::-;2430:139;;;;:::o;2575:117::-;2684:1;2681;2674:12;2698:117;2807:1;2804;2797:12;2821:117;2930:1;2927;2920:12;2961:568;3034:8;3044:6;3094:3;3087:4;3079:6;3075:17;3071:27;3061:122;;3102:79;;:::i;:::-;3061:122;3215:6;3202:20;3192:30;;3245:18;3237:6;3234:30;3231:117;;;3267:79;;:::i;:::-;3231:117;3381:4;3373:6;3369:17;3357:29;;3435:3;3427:4;3419:6;3415:17;3405:8;3401:32;3398:41;3395:128;;;3442:79;;:::i;:::-;3395:128;2961:568;;;;;:::o;3535:995::-;3648:6;3656;3664;3672;3680;3729:3;3717:9;3708:7;3704:23;3700:33;3697:120;;;3736:79;;:::i;:::-;3697:120;3856:1;3881:53;3926:7;3917:6;3906:9;3902:22;3881:53;:::i;:::-;3871:63;;3827:117;3983:2;4009:53;4054:7;4045:6;4034:9;4030:22;4009:53;:::i;:::-;3999:63;;3954:118;4111:2;4137:53;4182:7;4173:6;4162:9;4158:22;4137:53;:::i;:::-;4127:63;;4082:118;4267:2;4256:9;4252:18;4239:32;4298:18;4290:6;4287:30;4284:117;;;4320:79;;:::i;:::-;4284:117;4433:80;4505:7;4496:6;4485:9;4481:22;4433:80;:::i;:::-;4415:98;;;;4210:313;3535:995;;;;;;;;:::o;4536:118::-;4623:24;4641:5;4623:24;:::i;:::-;4618:3;4611:37;4536:118;;:::o;4660:222::-;4753:4;4791:2;4780:9;4776:18;4768:26;;4804:71;4872:1;4861:9;4857:17;4848:6;4804:71;:::i;:::-;4660:222;;;;:::o;4901:552::-;4958:8;4968:6;5018:3;5011:4;5003:6;4999:17;4995:27;4985:122;;5026:79;;:::i;:::-;4985:122;5139:6;5126:20;5116:30;;5169:18;5161:6;5158:30;5155:117;;;5191:79;;:::i;:::-;5155:117;5305:4;5297:6;5293:17;5281:29;;5359:3;5351:4;5343:6;5339:17;5329:8;5325:32;5322:41;5319:128;;;5366:79;;:::i;:::-;5319:128;4901:552;;;;;:::o;5459:672::-;5538:6;5546;5554;5603:2;5591:9;5582:7;5578:23;5574:32;5571:119;;;5609:79;;:::i;:::-;5571:119;5729:1;5754:53;5799:7;5790:6;5779:9;5775:22;5754:53;:::i;:::-;5744:63;;5700:117;5884:2;5873:9;5869:18;5856:32;5915:18;5907:6;5904:30;5901:117;;;5937:79;;:::i;:::-;5901:117;6050:64;6106:7;6097:6;6086:9;6082:22;6050:64;:::i;:::-;6032:82;;;;5827:297;5459:672;;;;;:::o;6137:90::-;6171:7;6214:5;6207:13;6200:21;6189:32;;6137:90;;;:::o;6233:109::-;6314:21;6329:5;6314:21;:::i;:::-;6309:3;6302:34;6233:109;;:::o;6348:98::-;6399:6;6433:5;6427:12;6417:22;;6348:98;;;:::o;6452:168::-;6535:11;6569:6;6564:3;6557:19;6609:4;6604:3;6600:14;6585:29;;6452:168;;;;:::o;6626:307::-;6694:1;6704:113;6718:6;6715:1;6712:13;6704:113;;;6803:1;6798:3;6794:11;6788:18;6784:1;6779:3;6775:11;6768:39;6740:2;6737:1;6733:10;6728:15;;6704:113;;;6835:6;6832:1;6829:13;6826:101;;;6915:1;6906:6;6901:3;6897:16;6890:27;6826:101;6675:258;6626:307;;;:::o;6939:102::-;6980:6;7031:2;7027:7;7022:2;7015:5;7011:14;7007:28;6997:38;;6939:102;;;:::o;7047:360::-;7133:3;7161:38;7193:5;7161:38;:::i;:::-;7215:70;7278:6;7273:3;7215:70;:::i;:::-;7208:77;;7294:52;7339:6;7334:3;7327:4;7320:5;7316:16;7294:52;:::i;:::-;7371:29;7393:6;7371:29;:::i;:::-;7366:3;7362:39;7355:46;;7137:270;7047:360;;;;:::o;7413:407::-;7546:4;7584:2;7573:9;7569:18;7561:26;;7597:65;7659:1;7648:9;7644:17;7635:6;7597:65;:::i;:::-;7709:9;7703:4;7699:20;7694:2;7683:9;7679:18;7672:48;7737:76;7808:4;7799:6;7737:76;:::i;:::-;7729:84;;7413:407;;;;;:::o;7826:118::-;7913:24;7931:5;7913:24;:::i;:::-;7908:3;7901:37;7826:118;;:::o;7950:222::-;8043:4;8081:2;8070:9;8066:18;8058:26;;8094:71;8162:1;8151:9;8147:17;8138:6;8094:71;:::i;:::-;7950:222;;;;:::o;8178:169::-;8262:11;8296:6;8291:3;8284:19;8336:4;8331:3;8327:14;8312:29;;8178:169;;;;:::o;8353:182::-;8493:34;8489:1;8481:6;8477:14;8470:58;8353:182;:::o;8541:366::-;8683:3;8704:67;8768:2;8763:3;8704:67;:::i;:::-;8697:74;;8780:93;8869:3;8780:93;:::i;:::-;8898:2;8893:3;8889:12;8882:19;;8541:366;;;:::o;8913:419::-;9079:4;9117:2;9106:9;9102:18;9094:26;;9166:9;9160:4;9156:20;9152:1;9141:9;9137:17;9130:47;9194:131;9320:4;9194:131;:::i;:::-;9186:139;;8913:419;;;:::o;9338:179::-;9478:31;9474:1;9466:6;9462:14;9455:55;9338:179;:::o;9523:366::-;9665:3;9686:67;9750:2;9745:3;9686:67;:::i;:::-;9679:74;;9762:93;9851:3;9762:93;:::i;:::-;9880:2;9875:3;9871:12;9864:19;;9523:366;;;:::o;9895:419::-;10061:4;10099:2;10088:9;10084:18;10076:26;;10148:9;10142:4;10138:20;10134:1;10123:9;10119:17;10112:47;10176:131;10302:4;10176:131;:::i;:::-;10168:139;;9895:419;;;:::o;10320:239::-;10460:34;10456:1;10448:6;10444:14;10437:58;10529:22;10524:2;10516:6;10512:15;10505:47;10320:239;:::o;10565:366::-;10707:3;10728:67;10792:2;10787:3;10728:67;:::i;:::-;10721:74;;10804:93;10893:3;10804:93;:::i;:::-;10922:2;10917:3;10913:12;10906:19;;10565:366;;;:::o;10937:419::-;11103:4;11141:2;11130:9;11126:18;11118:26;;11190:9;11184:4;11180:20;11176:1;11165:9;11161:17;11154:47;11218:131;11344:4;11218:131;:::i;:::-;11210:139;;10937:419;;;:::o;11362:79::-;11401:7;11430:5;11419:16;;11362:79;;;:::o;11447:157::-;11552:45;11572:24;11590:5;11572:24;:::i;:::-;11552:45;:::i;:::-;11547:3;11540:58;11447:157;;:::o;11610:94::-;11643:8;11691:5;11687:2;11683:14;11662:35;;11610:94;;;:::o;11710:::-;11749:7;11778:20;11792:5;11778:20;:::i;:::-;11767:31;;11710:94;;;:::o;11810:100::-;11849:7;11878:26;11898:5;11878:26;:::i;:::-;11867:37;;11810:100;;;:::o;11916:157::-;12021:45;12041:24;12059:5;12041:24;:::i;:::-;12021:45;:::i;:::-;12016:3;12009:58;11916:157;;:::o;12079:538::-;12247:3;12262:75;12333:3;12324:6;12262:75;:::i;:::-;12362:2;12357:3;12353:12;12346:19;;12375:75;12446:3;12437:6;12375:75;:::i;:::-;12475:2;12470:3;12466:12;12459:19;;12488:75;12559:3;12550:6;12488:75;:::i;:::-;12588:2;12583:3;12579:12;12572:19;;12608:3;12601:10;;12079:538;;;;;;:::o;12623:232::-;12763:34;12759:1;12751:6;12747:14;12740:58;12832:15;12827:2;12819:6;12815:15;12808:40;12623:232;:::o;12861:366::-;13003:3;13024:67;13088:2;13083:3;13024:67;:::i;:::-;13017:74;;13100:93;13189:3;13100:93;:::i;:::-;13218:2;13213:3;13209:12;13202:19;;12861:366;;;:::o;13233:419::-;13399:4;13437:2;13426:9;13422:18;13414:26;;13486:9;13480:4;13476:20;13472:1;13461:9;13457:17;13450:47;13514:131;13640:4;13514:131;:::i;:::-;13506:139;;13233:419;;;:::o;13658:180::-;13706:77;13703:1;13696:88;13803:4;13800:1;13793:15;13827:4;13824:1;13817:15;13844:191;13884:4;13904:20;13922:1;13904:20;:::i;:::-;13899:25;;13938:20;13956:1;13938:20;:::i;:::-;13933:25;;13977:1;13974;13971:8;13968:34;;;13982:18;;:::i;:::-;13968:34;14027:1;14024;14020:9;14012:17;;13844:191;;;;:::o;14041:332::-;14162:4;14200:2;14189:9;14185:18;14177:26;;14213:71;14281:1;14270:9;14266:17;14257:6;14213:71;:::i;:::-;14294:72;14362:2;14351:9;14347:18;14338:6;14294:72;:::i;:::-;14041:332;;;;;:::o;14379:116::-;14449:21;14464:5;14449:21;:::i;:::-;14442:5;14439:32;14429:60;;14485:1;14482;14475:12;14429:60;14379:116;:::o;14501:137::-;14555:5;14586:6;14580:13;14571:22;;14602:30;14626:5;14602:30;:::i;:::-;14501:137;;;;:::o;14644:345::-;14711:6;14760:2;14748:9;14739:7;14735:23;14731:32;14728:119;;;14766:79;;:::i;:::-;14728:119;14886:1;14911:61;14964:7;14955:6;14944:9;14940:22;14911:61;:::i;:::-;14901:71;;14857:125;14644:345;;;;:::o;14995:234::-;15135:34;15131:1;15123:6;15119:14;15112:58;15204:17;15199:2;15191:6;15187:15;15180:42;14995:234;:::o;15235:366::-;15377:3;15398:67;15462:2;15457:3;15398:67;:::i;:::-;15391:74;;15474:93;15563:3;15474:93;:::i;:::-;15592:2;15587:3;15583:12;15576:19;;15235:366;;;:::o;15607:419::-;15773:4;15811:2;15800:9;15796:18;15788:26;;15860:9;15854:4;15850:20;15846:1;15835:9;15831:17;15824:47;15888:131;16014:4;15888:131;:::i;:::-;15880:139;;15607:419;;;:::o;16032:442::-;16181:4;16219:2;16208:9;16204:18;16196:26;;16232:71;16300:1;16289:9;16285:17;16276:6;16232:71;:::i;:::-;16313:72;16381:2;16370:9;16366:18;16357:6;16313:72;:::i;:::-;16395;16463:2;16452:9;16448:18;16439:6;16395:72;:::i;:::-;16032:442;;;;;;:::o;16480:236::-;16620:34;16616:1;16608:6;16604:14;16597:58;16689:19;16684:2;16676:6;16672:15;16665:44;16480:236;:::o;16722:366::-;16864:3;16885:67;16949:2;16944:3;16885:67;:::i;:::-;16878:74;;16961:93;17050:3;16961:93;:::i;:::-;17079:2;17074:3;17070:12;17063:19;;16722:366;;;:::o;17094:419::-;17260:4;17298:2;17287:9;17283:18;17275:26;;17347:9;17341:4;17337:20;17333:1;17322:9;17318:17;17311:47;17375:131;17501:4;17375:131;:::i;:::-;17367:139;;17094:419;;;:::o;17519:147::-;17620:11;17657:3;17642:18;;17519:147;;;;:::o;17672:154::-;17756:6;17751:3;17746;17733:30;17818:1;17809:6;17804:3;17800:16;17793:27;17672:154;;;:::o;17854:314::-;17968:3;17989:88;18070:6;18065:3;17989:88;:::i;:::-;17982:95;;18087:43;18123:6;18118:3;18111:5;18087:43;:::i;:::-;18155:6;18150:3;18146:16;18139:23;;17854:314;;;;;:::o;18174:291::-;18314:3;18336:103;18435:3;18426:6;18418;18336:103;:::i;:::-;18329:110;;18456:3;18449:10;;18174:291;;;;;:::o;18471:225::-;18611:34;18607:1;18599:6;18595:14;18588:58;18680:8;18675:2;18667:6;18663:15;18656:33;18471:225;:::o;18702:366::-;18844:3;18865:67;18929:2;18924:3;18865:67;:::i;:::-;18858:74;;18941:93;19030:3;18941:93;:::i;:::-;19059:2;19054:3;19050:12;19043:19;;18702:366;;;:::o;19074:419::-;19240:4;19278:2;19267:9;19263:18;19255:26;;19327:9;19321:4;19317:20;19313:1;19302:9;19298:17;19291:47;19355:131;19481:4;19355:131;:::i;:::-;19347:139;;19074:419;;;:::o;19499:180::-;19547:77;19544:1;19537:88;19644:4;19641:1;19634:15;19668:4;19665:1;19658:15;19685:79;19724:7;19753:5;19742:16;;19685:79;;;:::o;19770:157::-;19875:45;19895:24;19913:5;19895:24;:::i;:::-;19875:45;:::i;:::-;19870:3;19863:58;19770:157;;:::o;19933:397::-;20073:3;20088:75;20159:3;20150:6;20088:75;:::i;:::-;20188:2;20183:3;20179:12;20172:19;;20201:75;20272:3;20263:6;20201:75;:::i;:::-;20301:2;20296:3;20292:12;20285:19;;20321:3;20314:10;;19933:397;;;;;:::o;20336:233::-;20375:3;20398:24;20416:5;20398:24;:::i;:::-;20389:33;;20444:66;20437:5;20434:77;20431:103;;;20514:18;;:::i;:::-;20431:103;20561:1;20554:5;20550:13;20543:20;;20336:233;;;:::o

ipfs://08775a21ceca8113feb8ea6ce27ae45755174f4504b4ef61bb4f20b781eabad0