Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

   - function _msgSender()    - function _msgData() interface IERC165    - function supportsInterface(bytes4 int ...    - function supportsInterface(bytes4 int ... library ECDSA    - function tryRecover(bytes32 hash, byt ...    - function recover(bytes32 hash, bytes ...    - function tryRecover(bytes32 hash, byt ...    - function recover(bytes32 hash, bytes3 ...    - function tryRecover(    - function recover(bytes32 hash, uint8 ...    - function _throwError(RecoverError err ... library Math    - function tryAdd(uint256 a, uint256 b)    - function trySub(uint256 a, uint256 b)    - function tryMul(uint256 a, uint256 b)    - function tryDiv(uint256 a, uint256 b)    - function tryMod(uint256 a, uint256 b)    - function max(uint256 a, uint256 b)    - function min(uint256 a, uint256 b)    - function average(uint256 a, uint256 b ...    - function ceilDiv(uint256 a, uint256 b ...    - function mulDiv(uint256 x, uint256 y, ...    - function mulDiv(uint256 x, uint256 y, ...    - function sqrt(uint256 a)    - function sqrt(uint256 a, Rounding rou ...    - function log2(uint256 value)    - function log2(uint256 value, Rounding ...    - function log10(uint256 value)    - function log10(uint256 value, Roundin ...    - function log256(uint256 value)    - function log256(uint256 value, Roundi ...    - function unsignedRoundsUp(Rounding ro ... library SignedMath    - function max(int256 a, int256 b)    - function min(int256 a, int256 b)    - function average(int256 a, int256 b)    - function abs(int256 n) library Strings    - function toString(uint256 value)    - function toStringSigned(int256 value)    - function toHexString(uint256 value)    - function toHexString(uint256 value, u ...    - function toHexString(address addr)    - function equal(string memory a, strin ...    - function owner()    - function _checkOwner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _transferOwnership(address n ... interface IERC721 is IERC165    - function balanceOf(address owner)    - function ownerOf(uint256 tokenId)    - function safeTransferFrom(address fro ...    - function safeTransferFrom(address fro ...    - function transferFrom(address from, a ...    - function approve(address to, uint256 ...    - function setApprovalForAll(address op ...    - function getApproved(uint256 tokenId)    - function isApprovedForAll(address own ... interface IERC721Receiver    - function onERC721Received( interface IERC721Metadata is IERC721    - function name()    - function symbol()    - function tokenURI(uint256 tokenId) interface FomoMofo is IERC721, IERC72 ...  contract ArtTour is FomoMofo, ERC1 ... *    - function name()    - function symbol()    - function supportsInterface(    - function onERC721Received(    - function balanceOf(address owner)    - function ownerOf(uint256 tokenId)    - function tokenURI(uint256 tokenId)    - function setTokenURI(string calldata ...    - function approve(address, uint256)    - function getApproved(uint256)    - function setApprovalForAll(address, b ...    - function isApprovedForAll(address, ad ...    - function transferFrom(    - function safeTransferFrom(    - function safeTransferFrom(    - function _transferRevert()    - function toggleStaking()    - function stake(    - function unstake(uint256[] calldata m ...    - function returnMofoWeDontKnowThough(a ...    - function stakingPeriod(uint256 tokenI ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-09-10
*/

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.21;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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


interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

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

    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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

library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS
    }

    /**
     * @dev The signature derives the `address(0)`.
     */
    error ECDSAInvalidSignature();

    /**
     * @dev The signature has an invalid length.
     */
    error ECDSAInvalidSignatureLength(uint256 length);

    /**
     * @dev The signature has an S value that is in the upper half order.
     */
    error ECDSAInvalidSignatureS(bytes32 s);

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
        unchecked {
            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            // We do not check for an overflow here since the shift operation results in 0 or 1.
            uint8 v = uint8((uint256(vs) >> 255) + 27);
            return tryRecover(hash, v, r, s);
        }
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError, bytes32) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS, s);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature, bytes32(0));
        }

        return (signer, RecoverError.NoError, bytes32(0));
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
     */
    function _throwError(RecoverError error, bytes32 errorArg) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert ECDSAInvalidSignature();
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert ECDSAInvalidSignatureLength(uint256(errorArg));
        } else if (error == RecoverError.InvalidSignatureS) {
            revert ECDSAInvalidSignatureS(errorArg);
        }
    }
}

library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // 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 (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant HEX_DIGITS = "0123456789abcdef";
    uint8 private constant ADDRESS_LENGTH = 20;

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

/**
 * @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.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @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 view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

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

    /**
     * @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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

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

interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

interface FomoMofo is IERC721, IERC721Metadata, IERC721Receiver {
    struct StakedOwner {
        address ownerAddress;
        uint48 entryTime;
    }
}

contract ArtTour is FomoMofo, ERC165, Ownable, ReentrancyGuard {
    using Strings for uint256;
    using ECDSA for bytes32;

    address public _fomoMofo;
    string private _name;
    string private _symbol;
    string public baseURI;
    bool public stakingIsEnabled;

    mapping(uint256 => StakedOwner) private _owners;
    mapping(address => uint256) private _balances;

    mapping(uint256 => uint256) private stakingStarted;
    mapping(uint256 => uint256) private stakingTotal;

    constructor(address fomoMofo) Ownable(msg.sender) {
        _fomoMofo = fomoMofo;
        _symbol = "ArtTour";
        _name = "Fomo Mofo ArtTour";
        baseURI = "ipfs://Qme1vxGNw9Wuh7RM3y6p5VvQWzui1gyMb3RfLoWcst3M8n/";
        stakingIsEnabled = false;
    }

    function name() external view returns (string memory) {
        return _name;
    }

    function symbol() external view returns (string memory) {
        return _symbol;
    }

    function supportsInterface(
        bytes4 interfaceId
    ) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    function onERC721Received(
        address,
        address from,
        uint256 tokenId,
        bytes calldata
    ) external override nonReentrant returns (bytes4) {
        require(stakingIsEnabled, "Staking is not enabled.");
        require(msg.sender == _fomoMofo, "FOMO MOFO's ONLY");

        stakingStarted[tokenId] = block.timestamp;
        _owners[tokenId] = StakedOwner(from, uint48(block.timestamp));
        unchecked {
            _balances[from] += 1;
        }
        emit Transfer(address(0), from, tokenId);

        return this.onERC721Received.selector;
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) external view override returns (uint256) {
        require(owner != address(0), "ERC721: address zero is not a valid owner");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) external view override returns (address) {
        address owner = _owners[tokenId].ownerAddress;
        require(owner != address(0), "ERC721: invalid token ID");
        return owner;
    }

    function tokenURI(uint256 tokenId) external view override returns (string memory) {
        require(_owners[tokenId].ownerAddress != address(0), "ERC721: invalid token ID");
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    function setTokenURI(string calldata uri) external onlyOwner {
        baseURI = uri;
    }

    function approve(address, uint256) external pure override {
        _transferRevert();
    }

    function getApproved(uint256) external pure override returns (address) {
        return address(0);
    }

    function setApprovalForAll(address, bool) external pure override {
        _transferRevert();
    }

    function isApprovedForAll(address, address) external pure override returns (bool) {
        return false;
    }

    function transferFrom(
        address,
        address,
        uint256
    ) external pure override {
        _transferRevert();
    }

    function safeTransferFrom(
        address,
        address,
        uint256
    ) external pure override {
        _transferRevert();
    }

    function safeTransferFrom(
        address,
        address,
        uint256,
        bytes memory
    ) external pure override {
        _transferRevert();
    }

    function _transferRevert() private pure {
        revert("Cannot perform transfers on a non-transferable token");
    }

    function toggleStaking() external onlyOwner {
        stakingIsEnabled = !stakingIsEnabled;
    }

    function stake(
        uint256[] calldata tokenIds
    ) external {
        for (uint256 i = 0; i < tokenIds.length;) {
            IERC721(_fomoMofo).safeTransferFrom(msg.sender, address(this), tokenIds[i]);
            unchecked {
                i++;
            }
        }
    }

    function unstake(uint256[] calldata mofoIds) external nonReentrant {
        uint256 length = mofoIds.length;

        for (uint256 i = 0; i < length;) {
            uint256 id = mofoIds[i];
            require(msg.sender == _owners[id].ownerAddress, "Address is not owner");

            unchecked {
                stakingTotal[id] += block.timestamp - stakingStarted[id];
                _balances[msg.sender] -= 1;
            }

            stakingStarted[id] = 0;
            _owners[id].ownerAddress = address(0);

            emit Transfer(msg.sender, address(0), id);

            IERC721(_fomoMofo).transferFrom(address(this), msg.sender, id);
            
            unchecked {
                i++;
            }
        }
    }

    function returnMofoWeDontKnowThough(address to, uint256 tokenId) external onlyOwner {
        require(_owners[tokenId].ownerAddress == address(0), "This Fomo Mofo is not lost");
        IERC721(_fomoMofo).transferFrom(address(this), to, tokenId);
    }

    function stakingPeriod(uint256 tokenId) external view
        returns (
            bool staking,
            uint256 current,
            uint256 total
        )
    {
        uint256 start = stakingStarted[tokenId];
        if (start != 0) {
            staking = true;
            current = block.timestamp - start;
        }
        total = current + stakingTotal[tokenId];
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"fomoMofo","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","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":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"_fomoMofo","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"returnMofoWeDontKnowThough","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"bool","name":"","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"string","name":"uri","type":"string"}],"name":"setTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakingIsEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"stakingPeriod","outputs":[{"internalType":"bool","name":"staking","type":"bool"},{"internalType":"uint256","name":"current","type":"uint256"},{"internalType":"uint256","name":"total","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toggleStaking","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"mofoIds","type":"uint256[]"}],"name":"unstake","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000818a19a6d3f0859b68e8490a6e945a51060caad1

-----Decoded View---------------
Arg [0] : fomoMofo (address): 0x818A19A6D3f0859B68e8490a6E945a51060CAaD1

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000818a19a6d3f0859b68e8490a6e945a51060caad1

38310:5762:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39285:321;;;;;;:::i;:::-;;:::i;:::-;;;470:14:1;;463:22;445:41;;433:2;418:18;39285:321:0;;;;;;;;39095:85;;;:::i;:::-;;;;;;;:::i;41275:107::-;;;;;;:::i;:::-;-1:-1:-1;41337:7:0;;41275:107;;;;-1:-1:-1;;;;;1502:32:1;;;1484:51;;1472:2;1457:18;41275:107:0;1338:203:1;41173:94:0;;;;;;:::i;:::-;;:::i;:::-;;42337:293;;;;;;:::i;:::-;;:::i;39614:601::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;;3748:33:1;;;3730:52;;3718:2;3703:18;39614:601:0;3586:202:1;41620:142:0;;;;;;:::i;:::-;;:::i;42230:99::-;;;:::i;40542:229::-;;;;;;:::i;:::-;;:::i;38531:21::-;;;:::i;40279:201::-;;;;;;:::i;:::-;;:::i;:::-;;;4463:25:1;;;4451:2;4436:18;40279:201:0;4317:177:1;31360:103:0;;;:::i;30685:87::-;30731:7;30758:6;-1:-1:-1;;;;;30758:6:0;30685:87;;39188:89;;;:::i;38559:28::-;;;;;;;;;38444:24;;;;;-1:-1:-1;;;;;38444:24:0;;;41390:101;;;;;;:::i;41924:169::-;;;;;;:::i;:::-;;:::i;43673:396::-;;;;;;:::i;:::-;;:::i;:::-;;;;6347:14:1;;6340:22;6322:41;;6394:2;6379:18;;6372:34;;;;6422:18;;;6415:34;6310:2;6295:18;43673:396:0;6126:329:1;40779:285:0;;;;;;:::i;:::-;;:::i;43410:255::-;;;;;;:::i;:::-;;:::i;41072:93::-;;;;;;:::i;:::-;;:::i;42638:764::-;;;;;;:::i;:::-;;:::i;41499:113::-;;;;;;:::i;:::-;41575:4;41499:113;;;;;31618:220;;;;;;:::i;:::-;;:::i;39285:321::-;39403:4;-1:-1:-1;;;;;;39440:40:0;;-1:-1:-1;;;39440:40:0;;:105;;-1:-1:-1;;;;;;;39497:48:0;;-1:-1:-1;;;39497:48:0;39440:105;:158;;;-1:-1:-1;;;;;;;;;;985:40:0;;;39562:36;39420:178;39285:321;-1:-1:-1;;39285:321:0:o;39095:85::-;39134:13;39167:5;39160:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39095:85;:::o;41173:94::-;41242:17;:15;:17::i;:::-;41173:94;;:::o;42337:293::-;42422:9;42417:206;42437:19;;;42417:206;;;42482:9;;-1:-1:-1;;;;;42482:9:0;42474:35;42510:10;42530:4;42537:8;;42546:1;42537:11;;;;;;;:::i;:::-;42474:75;;-1:-1:-1;;;;;;42474:75:0;;;;;;;-1:-1:-1;;;;;7915:15:1;;;42474:75:0;;;7897:34:1;7967:15;;;;7947:18;;;7940:43;-1:-1:-1;42537:11:0;;;;;;7999:18:1;;;7992:34;7832:18;;42474:75:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;42593:3:0;;;;;-1:-1:-1;42417:206:0;;-1:-1:-1;42417:206:0;;;42337:293;;:::o;39614:601::-;39779:6;1924:1;2144:7;;:19;2136:63;;;;-1:-1:-1;;;2136:63:0;;8239:2:1;2136:63:0;;;8221:21:1;8278:2;8258:18;;;8251:30;8317:33;8297:18;;;8290:61;8368:18;;2136:63:0;;;;;;;;;1924:1;2277:7;:18;39806:16:::1;::::0;::::1;;39798:52;;;::::0;-1:-1:-1;;;39798:52:0;;8599:2:1;39798:52:0::1;::::0;::::1;8581:21:1::0;8638:2;8618:18;;;8611:30;8677:25;8657:18;;;8650:53;8720:18;;39798:52:0::1;8397:347:1::0;39798:52:0::1;39883:9;::::0;-1:-1:-1;;;;;39883:9:0::1;39869:10;:23;39861:52;;;::::0;-1:-1:-1;;;39861:52:0;;8951:2:1;39861:52:0::1;::::0;::::1;8933:21:1::0;8990:2;8970:18;;;8963:30;-1:-1:-1;;;9009:18:1;;;9002:46;9065:18;;39861:52:0::1;8749:340:1::0;39861:52:0::1;39926:23;::::0;;;:14:::1;:23;::::0;;;;;;;39952:15:::1;39926:41:::0;;;;39997:42;;;;::::1;::::0;;-1:-1:-1;;;;;39997:42:0;;::::1;::::0;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;;39978:16;;;:7:::1;:16:::0;;;;;:61;;;;;;;;::::1;-1:-1:-1::0;;;39978:61:0::1;-1:-1:-1::0;;;;;;39978:61:0;;;;;;::::1;::::0;;;;::::1;::::0;;40075:15;;;:9:::1;:15:::0;;;;;;:20;;39978:61;40075:20:::1;::::0;;40122:35;39941:7;;39926:23;40122:35:::1;::::0;39926:23;;40122:35:::1;-1:-1:-1::0;;;;1880:1:0;2456:22;;39614:601;;-1:-1:-1;;;;;39614:601:0:o;41620:142::-;41737:17;:15;:17::i;42230:99::-;30571:13;:11;:13::i;:::-;42305:16:::1;::::0;;-1:-1:-1;;42285:36:0;::::1;42305:16;::::0;;::::1;42304:17;42285:36;::::0;;42230:99::o;40542:229::-;40608:7;40644:16;;;:7;:16;;;;;:29;-1:-1:-1;;;;;40644:29:0;;40684:56;;;;-1:-1:-1;;;40684:56:0;;9296:2:1;40684:56:0;;;9278:21:1;9335:2;9315:18;;;9308:30;-1:-1:-1;;;9354:18:1;;;9347:54;9418:18;;40684:56:0;9094:348:1;38531:21:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;40279:201::-;40345:7;-1:-1:-1;;;;;40373:19:0;;40365:73;;;;-1:-1:-1;;;40365:73:0;;9649:2:1;40365:73:0;;;9631:21:1;9688:2;9668:18;;;9661:30;9727:34;9707:18;;;9700:62;-1:-1:-1;;;9778:18:1;;;9771:39;9827:19;;40365:73:0;9447:405:1;40365:73:0;-1:-1:-1;;;;;;40456:16:0;;;;;:9;:16;;;;;;;40279:201::o;31360:103::-;30571:13;:11;:13::i;:::-;31425:30:::1;31452:1;31425:18;:30::i;:::-;31360:103::o:0;39188:89::-;39229:13;39262:7;39255:14;;;;;:::i;41924:169::-;42068:17;:15;:17::i;:::-;41924:169;;;;:::o;43673:396::-;43759:12;43873:23;;;:14;:23;;;;;;43759:12;;;;43911:10;;43907:105;;43948:4;;-1:-1:-1;43977:23:0;43995:5;43977:15;:23;:::i;:::-;43967:33;;43907:105;44040:21;;;;:12;:21;;;;;;44030:31;;:7;:31;:::i;:::-;43673:396;;;;-1:-1:-1;;;43673:396:0:o;40779:285::-;40921:1;40880:16;;;:7;:16;;;;;:29;40846:13;;-1:-1:-1;;;;;40880:29:0;40872:80;;;;-1:-1:-1;;;40872:80:0;;9296:2:1;40872:80:0;;;9278:21:1;9335:2;9315:18;;;9308:30;-1:-1:-1;;;9354:18:1;;;9347:54;9418:18;;40872:80:0;9094:348:1;40872:80:0;40994:1;40976:7;40970:21;;;;;:::i;:::-;;;:25;:86;;;;;;;;;;;;;;;;;41022:7;41031:18;:7;:16;:18::i;:::-;41005:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;40963:93;40779:285;-1:-1:-1;;40779:285:0:o;43410:255::-;30571:13;:11;:13::i;:::-;43554:1:::1;43513:16:::0;;;:7:::1;:16;::::0;;;;:29;-1:-1:-1;;;;;43513:29:0::1;:43:::0;43505:82:::1;;;::::0;-1:-1:-1;;;43505:82:0;;11605:2:1;43505:82:0::1;::::0;::::1;11587:21:1::0;11644:2;11624:18;;;11617:30;11683:28;11663:18;;;11656:56;11729:18;;43505:82:0::1;11403:350:1::0;43505:82:0::1;43606:9;::::0;43598:59:::1;::::0;-1:-1:-1;;;43598:59:0;;43638:4:::1;43598:59;::::0;::::1;7897:34:1::0;-1:-1:-1;;;;;7967:15:1;;;7947:18;;;7940:43;7999:18;;;7992:34;;;43606:9:0;;::::1;::::0;43598:31:::1;::::0;7832:18:1;;43598:59:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;43410:255:::0;;:::o;41072:93::-;30571:13;:11;:13::i;:::-;41144:7:::1;:13;41154:3:::0;;41144:7;:13:::1;:::i;42638:764::-:0;1924:1;2144:7;;:19;2136:63;;;;-1:-1:-1;;;2136:63:0;;8239:2:1;2136:63:0;;;8221:21:1;8278:2;8258:18;;;8251:30;8317:33;8297:18;;;8290:61;8368:18;;2136:63:0;8037:355:1;2136:63:0;1924:1;2277:7;:18;42733:7;42716:14:::1;42760:635;42784:6;42780:1;:10;42760:635;;;42808:10;42821:7;;42829:1;42821:10;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;::::1;;42868:11;::::0;;;:7:::1;:11:::0;;;;;;;:24;42821:10;;-1:-1:-1;;;;;;;42868:24:0::1;42854:10;:38;42846:71;;;::::0;-1:-1:-1;;;42846:71:0;;13892:2:1;42846:71:0::1;::::0;::::1;13874:21:1::0;13931:2;13911:18;;;13904:30;-1:-1:-1;;;13950:18:1;;;13943:50;14010:18;;42846:71:0::1;13690:344:1::0;42846:71:0::1;43001:18;::::0;;;:14:::1;:18;::::0;;;;;;;;;42963:12:::1;:16:::0;;;;;:56;;42983:15:::1;:36:::0;;;::::1;42963:56:::0;;::::1;::::0;;43048:10:::1;43038:21:::0;;;:9:::1;:21:::0;;;;;:26;;-1:-1:-1;;43038:26:0;;;43096:18;;;:22;;;;43133:7:::1;:11:::0;;;;;;:37;;-1:-1:-1;;;;;;43133:37:0::1;::::0;;43192:36;43001:18;;;43048:10;43192:36:::1;::::0;43001:18;;43192:36:::1;43253:9;::::0;43245:62:::1;::::0;-1:-1:-1;;;43245:62:0;;43285:4:::1;43245:62;::::0;::::1;7897:34:1::0;43292:10:0::1;7947:18:1::0;;;7940:43;7999:18;;;7992:34;;;-1:-1:-1;;;;;43253:9:0;;::::1;::::0;43245:31:::1;::::0;7832:18:1;;43245:62:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;43365:3:0::1;::::0;;::::1;::::0;-1:-1:-1;42760:635:0::1;::::0;-1:-1:-1;;42760:635:0::1;;-1:-1:-1::0;;1880:1:0;2456:22;;-1:-1:-1;;42638:764:0:o;31618:220::-;30571:13;:11;:13::i;:::-;-1:-1:-1;;;;;31703:22:0;::::1;31699:93;;31749:31;::::0;-1:-1:-1;;;31749:31:0;;31777:1:::1;31749:31;::::0;::::1;1484:51:1::0;1457:18;;31749:31:0::1;1338:203:1::0;31699:93:0::1;31802:28;31821:8;31802:18;:28::i;:::-;31618:220:::0;:::o;42101:121::-;42152:62;;-1:-1:-1;;;42152:62:0;;14241:2:1;42152:62:0;;;14223:21:1;14280:2;14260:18;;;14253:30;14319:34;14299:18;;;14292:62;-1:-1:-1;;;14370:18:1;;;14363:50;14430:19;;42152:62:0;14039:416:1;30850:166:0;30731:7;30758:6;-1:-1:-1;;;;;30758:6:0;181:10;30910:23;30906:103;;30957:40;;-1:-1:-1;;;30957:40:0;;181:10;30957:40;;;1484:51:1;1457:18;;30957:40:0;1338:203:1;31998:191:0;32072:16;32091:6;;-1:-1:-1;;;;;32108:17:0;;;-1:-1:-1;;;;;;32108:17:0;;;;;;32141:40;;32091:6;;;;;;;32141:40;;32072:16;32141:40;32061:128;31998:191;:::o;26647:718::-;26703:13;26754:14;26771:17;26782:5;26771:10;:17::i;:::-;26791:1;26771:21;26754:38;;26807:20;26841:6;26830:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;26830:18:0;-1:-1:-1;26807:41:0;-1:-1:-1;26972:28:0;;;26988:2;26972:28;27029:290;-1:-1:-1;;27061:5:0;-1:-1:-1;;;27198:2:0;27187:14;;27182:32;27061:5;27169:46;27261:2;27252:11;;;-1:-1:-1;27282:21:0;27029:290;27282:21;-1:-1:-1;27340:6:0;26647:718;-1:-1:-1;;;26647:718:0:o;22125:948::-;22178:7;;-1:-1:-1;;;22256:17:0;;22252:106;;-1:-1:-1;;;22294:17:0;;;-1:-1:-1;22340:2:0;22330:12;22252:106;22385:8;22376:5;:17;22372:106;;22423:8;22414:17;;;-1:-1:-1;22460:2:0;22450:12;22372:106;22505:8;22496:5;:17;22492:106;;22543:8;22534:17;;;-1:-1:-1;22580:2:0;22570:12;22492:106;22625:7;22616:5;:16;22612:103;;22662:7;22653:16;;;-1:-1:-1;22698:1:0;22688:11;22612:103;22742:7;22733:5;:16;22729:103;;22779:7;22770:16;;;-1:-1:-1;22815:1:0;22805:11;22729:103;22859:7;22850:5;:16;22846:103;;22896:7;22887:16;;;-1:-1:-1;22932:1:0;22922:11;22846:103;22976:7;22967:5;:16;22963:68;;23014:1;23004:11;23059:6;22125:948;-1:-1:-1;;22125:948:0:o;14:286:1:-;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;167:23;;-1:-1:-1;;;;;;219:32:1;;209:43;;199:71;;266:1;263;256:12;199:71;289:5;14:286;-1:-1:-1;;;14:286:1:o;497:250::-;582:1;592:113;606:6;603:1;600:13;592:113;;;682:11;;;676:18;663:11;;;656:39;628:2;621:10;592:113;;;-1:-1:-1;;739:1:1;721:16;;714:27;497:250::o;752:396::-;901:2;890:9;883:21;864:4;933:6;927:13;976:6;971:2;960:9;956:18;949:34;992:79;1064:6;1059:2;1048:9;1044:18;1039:2;1031:6;1027:15;992:79;:::i;:::-;1132:2;1111:15;-1:-1:-1;;1107:29:1;1092:45;;;;1139:2;1088:54;;752:396;-1:-1:-1;;752:396:1:o;1153:180::-;1212:6;1265:2;1253:9;1244:7;1240:23;1236:32;1233:52;;;1281:1;1278;1271:12;1233:52;-1:-1:-1;1304:23:1;;1153:180;-1:-1:-1;1153:180:1:o;1546:173::-;1614:20;;-1:-1:-1;;;;;1663:31:1;;1653:42;;1643:70;;1709:1;1706;1699:12;1643:70;1546:173;;;:::o;1724:254::-;1792:6;1800;1853:2;1841:9;1832:7;1828:23;1824:32;1821:52;;;1869:1;1866;1859:12;1821:52;1892:29;1911:9;1892:29;:::i;:::-;1882:39;1968:2;1953:18;;;;1940:32;;-1:-1:-1;;;1724:254:1:o;1983:615::-;2069:6;2077;2130:2;2118:9;2109:7;2105:23;2101:32;2098:52;;;2146:1;2143;2136:12;2098:52;2186:9;2173:23;2215:18;2256:2;2248:6;2245:14;2242:34;;;2272:1;2269;2262:12;2242:34;2310:6;2299:9;2295:22;2285:32;;2355:7;2348:4;2344:2;2340:13;2336:27;2326:55;;2377:1;2374;2367:12;2326:55;2417:2;2404:16;2443:2;2435:6;2432:14;2429:34;;;2459:1;2456;2449:12;2429:34;2512:7;2507:2;2497:6;2494:1;2490:14;2486:2;2482:23;2478:32;2475:45;2472:65;;;2533:1;2530;2523:12;2472:65;2564:2;2556:11;;;;;2586:6;;-1:-1:-1;1983:615:1;;-1:-1:-1;;;;1983:615:1:o;2603:347::-;2654:8;2664:6;2718:3;2711:4;2703:6;2699:17;2695:27;2685:55;;2736:1;2733;2726:12;2685:55;-1:-1:-1;2759:20:1;;2802:18;2791:30;;2788:50;;;2834:1;2831;2824:12;2788:50;2871:4;2863:6;2859:17;2847:29;;2923:3;2916:4;2907:6;2899;2895:19;2891:30;2888:39;2885:59;;;2940:1;2937;2930:12;2885:59;2603:347;;;;;:::o;2955:626::-;3052:6;3060;3068;3076;3084;3137:3;3125:9;3116:7;3112:23;3108:33;3105:53;;;3154:1;3151;3144:12;3105:53;3177:29;3196:9;3177:29;:::i;:::-;3167:39;;3225:38;3259:2;3248:9;3244:18;3225:38;:::i;:::-;3215:48;;3310:2;3299:9;3295:18;3282:32;3272:42;;3365:2;3354:9;3350:18;3337:32;3392:18;3384:6;3381:30;3378:50;;;3424:1;3421;3414:12;3378:50;3463:58;3513:7;3504:6;3493:9;3489:22;3463:58;:::i;:::-;2955:626;;;;-1:-1:-1;2955:626:1;;-1:-1:-1;3540:8:1;;3437:84;2955:626;-1:-1:-1;;;2955:626:1:o;3793:328::-;3870:6;3878;3886;3939:2;3927:9;3918:7;3914:23;3910:32;3907:52;;;3955:1;3952;3945:12;3907:52;3978:29;3997:9;3978:29;:::i;:::-;3968:39;;4026:38;4060:2;4049:9;4045:18;4026:38;:::i;:::-;4016:48;;4111:2;4100:9;4096:18;4083:32;4073:42;;3793:328;;;;;:::o;4126:186::-;4185:6;4238:2;4226:9;4217:7;4213:23;4209:32;4206:52;;;4254:1;4251;4244:12;4206:52;4277:29;4296:9;4277:29;:::i;4499:347::-;4564:6;4572;4625:2;4613:9;4604:7;4600:23;4596:32;4593:52;;;4641:1;4638;4631:12;4593:52;4664:29;4683:9;4664:29;:::i;:::-;4654:39;;4743:2;4732:9;4728:18;4715:32;4790:5;4783:13;4776:21;4769:5;4766:32;4756:60;;4812:1;4809;4802:12;4756:60;4835:5;4825:15;;;4499:347;;;;;:::o;4851:127::-;4912:10;4907:3;4903:20;4900:1;4893:31;4943:4;4940:1;4933:15;4967:4;4964:1;4957:15;4983:1138;5078:6;5086;5094;5102;5155:3;5143:9;5134:7;5130:23;5126:33;5123:53;;;5172:1;5169;5162:12;5123:53;5195:29;5214:9;5195:29;:::i;:::-;5185:39;;5243:38;5277:2;5266:9;5262:18;5243:38;:::i;:::-;5233:48;;5328:2;5317:9;5313:18;5300:32;5290:42;;5383:2;5372:9;5368:18;5355:32;5406:18;5447:2;5439:6;5436:14;5433:34;;;5463:1;5460;5453:12;5433:34;5501:6;5490:9;5486:22;5476:32;;5546:7;5539:4;5535:2;5531:13;5527:27;5517:55;;5568:1;5565;5558:12;5517:55;5604:2;5591:16;5626:2;5622;5619:10;5616:36;;;5632:18;;:::i;:::-;5707:2;5701:9;5675:2;5761:13;;-1:-1:-1;;5757:22:1;;;5781:2;5753:31;5749:40;5737:53;;;5805:18;;;5825:22;;;5802:46;5799:72;;;5851:18;;:::i;:::-;5891:10;5887:2;5880:22;5926:2;5918:6;5911:18;5966:7;5961:2;5956;5952;5948:11;5944:20;5941:33;5938:53;;;5987:1;5984;5977:12;5938:53;6043:2;6038;6034;6030:11;6025:2;6017:6;6013:15;6000:46;6088:1;6083:2;6078;6070:6;6066:15;6062:24;6055:35;6109:6;6099:16;;;;;;;4983:1138;;;;;;;:::o;6460:410::-;6531:6;6539;6592:2;6580:9;6571:7;6567:23;6563:32;6560:52;;;6608:1;6605;6598:12;6560:52;6648:9;6635:23;6681:18;6673:6;6670:30;6667:50;;;6713:1;6710;6703:12;6667:50;6752:58;6802:7;6793:6;6782:9;6778:22;6752:58;:::i;:::-;6829:8;;6726:84;;-1:-1:-1;6460:410:1;-1:-1:-1;;;;6460:410:1:o;6875:260::-;6943:6;6951;7004:2;6992:9;6983:7;6979:23;6975:32;6972:52;;;7020:1;7017;7010:12;6972:52;7043:29;7062:9;7043:29;:::i;:::-;7033:39;;7091:38;7125:2;7114:9;7110:18;7091:38;:::i;:::-;7081:48;;6875:260;;;;;:::o;7140:380::-;7219:1;7215:12;;;;7262;;;7283:61;;7337:4;7329:6;7325:17;7315:27;;7283:61;7390:2;7382:6;7379:14;7359:18;7356:38;7353:161;;7436:10;7431:3;7427:20;7424:1;7417:31;7471:4;7468:1;7461:15;7499:4;7496:1;7489:15;7353:161;;7140:380;;;:::o;7525:127::-;7586:10;7581:3;7577:20;7574:1;7567:31;7617:4;7614:1;7607:15;7641:4;7638:1;7631:15;9857:127;9918:10;9913:3;9909:20;9906:1;9899:31;9949:4;9946:1;9939:15;9973:4;9970:1;9963:15;9989:128;10056:9;;;10077:11;;;10074:37;;;10091:18;;:::i;10122:125::-;10187:9;;;10208:10;;;10205:36;;;10221:18;;:::i;10378:1020::-;10554:3;10583:1;10616:6;10610:13;10646:36;10672:9;10646:36;:::i;:::-;10701:1;10718:18;;;10745:133;;;;10892:1;10887:356;;;;10711:532;;10745:133;-1:-1:-1;;10778:24:1;;10766:37;;10851:14;;10844:22;10832:35;;10823:45;;;-1:-1:-1;10745:133:1;;10887:356;10918:6;10915:1;10908:17;10948:4;10993:2;10990:1;10980:16;11018:1;11032:165;11046:6;11043:1;11040:13;11032:165;;;11124:14;;11111:11;;;11104:35;11167:16;;;;11061:10;;11032:165;;;11036:3;;;11226:6;11221:3;11217:16;11210:23;;10711:532;;;;;11274:6;11268:13;11290:68;11349:8;11344:3;11337:4;11329:6;11325:17;11290:68;:::i;:::-;11374:18;;10378:1020;-1:-1:-1;;;;10378:1020:1:o;11758:545::-;11860:2;11855:3;11852:11;11849:448;;;11896:1;11921:5;11917:2;11910:17;11966:4;11962:2;11952:19;12036:2;12024:10;12020:19;12017:1;12013:27;12007:4;12003:38;12072:4;12060:10;12057:20;12054:47;;;-1:-1:-1;12095:4:1;12054:47;12150:2;12145:3;12141:12;12138:1;12134:20;12128:4;12124:31;12114:41;;12205:82;12223:2;12216:5;12213:13;12205:82;;;12268:17;;;12249:1;12238:13;12205:82;;12479:1206;12603:18;12598:3;12595:27;12592:53;;;12625:18;;:::i;:::-;12654:94;12744:3;12704:38;12736:4;12730:11;12704:38;:::i;:::-;12698:4;12654:94;:::i;:::-;12774:1;12799:2;12794:3;12791:11;12816:1;12811:616;;;;13471:1;13488:3;13485:93;;;-1:-1:-1;13544:19:1;;;13531:33;13485:93;-1:-1:-1;;12436:1:1;12432:11;;;12428:24;12424:29;12414:40;12460:1;12456:11;;;12411:57;13591:78;;12784:895;;12811:616;10325:1;10318:14;;;10362:4;10349:18;;-1:-1:-1;;12847:17:1;;;12948:9;12970:229;12984:7;12981:1;12978:14;12970:229;;;13073:19;;;13060:33;13045:49;;13180:4;13165:20;;;;13133:1;13121:14;;;;13000:12;12970:229;;;12974:3;13227;13218:7;13215:16;13212:159;;;13351:1;13347:6;13341:3;13335;13332:1;13328:11;13324:21;13320:34;13316:39;13303:9;13298:3;13294:19;13281:33;13277:79;13269:6;13262:95;13212:159;;;13414:1;13408:3;13405:1;13401:11;13397:19;13391:4;13384:33;12784:895;;;12479:1206;;;:::o

ipfs://49f591b8bd722d15a537fca30b32703c00d30a1f674ca8aeee6a70bc1afa12f0