Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at Nova.Arbiscan.io on 2023-01-20
*/

// File: @openzeppelin/contracts/utils/cryptography/MerkleProof.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/**
 * @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 rebuild 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 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 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 for 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) {
            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 rebuild 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 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 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 for 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) {
            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)
        }
    }
}

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _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;
    }
}

// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @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 up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (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; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 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.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            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 (rounding == Rounding.Up && 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 down.
     *
     * 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 + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * 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 + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * 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 + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * 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 10, 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 + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

// File: @openzeppelin/contracts/utils/Strings.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;


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

    /**
     * @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), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @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) {
        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] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        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);
    }
}

// File: @openzeppelin/contracts/utils/Context.sol


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

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev 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 {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

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

// File: @openzeppelin/contracts/utils/Address.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
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);
}

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
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);
}

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
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 caller.
     *
     * 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);
}

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
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);
}

// File: contracts/ERC721A.sol


// Creator: Chiru Labs

pragma solidity ^0.8.4;








error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).
 *
 * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 *
 * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Compiler will pack this into a single 256bit word.
    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Keeps track of the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
    }

    // Compiler will pack this into a single 256bit word.
    struct AddressData {
        // Realistically, 2**64-1 is more than enough.
        uint64 balance;
        // Keeps track of mint count with minimal overhead for tokenomics.
        uint64 numberMinted;
        // Keeps track of burn count with minimal overhead for tokenomics.
        uint64 numberBurned;
        // For miscellaneous variable(s) pertaining to the address
        // (e.g. number of whitelist mint slots used).
        // If there are multiple variables, please pack them into a uint64.
        uint64 aux;
    }

    // The tokenId of the next token to be minted.
    uint256 internal _currentIndex;

    // The number of tokens burned.
    uint256 internal _burnCounter;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to ownership details
    // An empty struct value does not necessarily mean the token is unowned. See _ownershipOf implementation for details.
    mapping(uint256 => TokenOwnership) internal _ownerships;

    // Mapping owner address to address data
    mapping(address => AddressData) private _addressData;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
        _currentIndex = _startTokenId();
    }

    /**
     * To change the starting tokenId, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 0;
    }

    /**
     * @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
     */
    function totalSupply() public view returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than _currentIndex - _startTokenId() times
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

    /**
     * Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view returns (uint256) {
        // Counter underflow is impossible as _currentIndex does not decrement,
        // and it is initialized to _startTokenId()
        unchecked {
            return _currentIndex - _startTokenId();
        }
    }

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return uint256(_addressData[owner].balance);
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberMinted);
    }

    /**
     * Returns the number of tokens burned by or on behalf of `owner`.
     */
    function _numberBurned(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberBurned);
    }

    /**
     * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     */
    function _getAux(address owner) internal view returns (uint64) {
        return _addressData[owner].aux;
    }

    /**
     * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal {
        _addressData[owner].aux = aux;
    }

    /**
     * Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around in the collection over time.
     */
    function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr && curr < _currentIndex) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (!ownership.burned) {
                    if (ownership.addr != address(0)) {
                        return ownership;
                    }
                    // Invariant:
                    // There will always be an ownership that has an address and is not burned
                    // before an ownership that does not have an address and is not burned.
                    // Hence, curr will not underflow.
                    while (true) {
                        curr--;
                        ownership = _ownerships[curr];
                        if (ownership.addr != address(0)) {
                            return ownership;
                        }
                    }
                }
            }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view override returns (address) {
        return _ownershipOf(tokenId).addr;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

        string memory baseURI = _baseURI();
        return bytes(baseURI).length != 0 ? baseURI : '';
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return '';
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public override {
        address owner = ERC721A.ownerOf(tokenId);
        if (to == owner) revert ApprovalToCurrentOwner();

        if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
            revert ApprovalCallerNotOwnerNorApproved();
        }

        _approve(to, tokenId, owner);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        if (operator == _msgSender()) revert ApproveToCaller();

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, '');
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        _transfer(from, to, tokenId);
        if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
            revert TransferToNonERC721ReceiverImplementer();
        }
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        return _startTokenId() <= tokenId && tokenId < _currentIndex && !_ownerships[tokenId].burned;
    }

    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, '');
    }

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        _mint(to, quantity, _data, true);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _mint(
        address to,
        uint256 quantity,
        bytes memory _data,
        bool safe
    ) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint64(quantity);
            _addressData[to].numberMinted += uint64(quantity);

            _ownerships[startTokenId].addr = to;
            _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            if (safe && to.isContract()) {
                do {
                    emit Transfer(address(0), to, updatedIndex);
                    if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (updatedIndex != end);
                // Reentrancy protection
                if (_currentIndex != startTokenId) revert();
            } else {
                do {
                    emit Transfer(address(0), to, updatedIndex++);
                } while (updatedIndex != end);
            }
            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) private {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();

        bool isApprovedOrOwner = (_msgSender() == from ||
            isApprovedForAll(from, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId, from);

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            _addressData[from].balance -= 1;
            _addressData[to].balance += 1;

            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = to;
            currSlot.startTimestamp = uint64(block.timestamp);

            // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, to, tokenId);
        _afterTokenTransfers(from, to, tokenId, 1);
    }

    /**
     * @dev This is equivalent to _burn(tokenId, false)
     */
    function _burn(uint256 tokenId) internal virtual {
        _burn(tokenId, false);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        address from = prevOwnership.addr;

        if (approvalCheck) {
            bool isApprovedOrOwner = (_msgSender() == from ||
                isApprovedForAll(from, _msgSender()) ||
                getApproved(tokenId) == _msgSender());

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

        _beforeTokenTransfers(from, address(0), tokenId, 1);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId, from);

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            AddressData storage addressData = _addressData[from];
            addressData.balance -= 1;
            addressData.numberBurned += 1;

            // Keep track of who burned the token, and the timestamp of burning.
            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = from;
            currSlot.startTimestamp = uint64(block.timestamp);
            currSlot.burned = true;

            // If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, address(0), tokenId);
        _afterTokenTransfers(from, address(0), tokenId, 1);

        // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
        unchecked {
            _burnCounter++;
        }
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(
        address to,
        uint256 tokenId,
        address owner
    ) private {
        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
            return retval == IERC721Receiver(to).onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == 0) {
                revert TransferToNonERC721ReceiverImplementer();
            } else {
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     * And also called before burning one token.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
     * minting.
     * And also called after one token has been burned.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
     * transferred to `to`.
     * - When `from` is zero, `tokenId` has been minted for `to`.
     * - When `to` is zero, `tokenId` has been burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}
// File: fronk.sol



pragma solidity ^0.8.7;





contract FronkWorld is ERC721A, Ownable, ReentrancyGuard {
    address public vault;
    bytes32 public merkleRoot;
    string public baseTokenURI;
    uint public price;
    uint public status = 0;
    uint public maxPerTx;

    mapping(address => uint) public minted;

    constructor(
        uint _price, 
        address _vault,
        uint _maxPerTx,
        string memory _tokenName,
        string memory _tokenSymbol
        )
    ERC721A(_tokenName, _tokenSymbol){
        setPrice(_price);
        setVault(_vault);
        maxPerTx= _maxPerTx;
    }

    function _baseURI() internal view virtual override returns (string memory) {
        return baseTokenURI;
    }

    function setBaseTokenURI(string calldata _baseTokenURI) external onlyOwner {
        baseTokenURI = _baseTokenURI;
    }

    function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
        merkleRoot = _merkleRoot;
    }

    function setPrice(uint _price) public onlyOwner {
        price = _price;
    }

    function setStatus(uint _status) external onlyOwner {
        status = _status;
    }

    function setVault(address _vault) public onlyOwner {
        vault = _vault;
    }

    function whitelistMint(bytes32[] calldata _merkleProof, uint _amount) external nonReentrant payable {
        require(status == 1, 'Not Active');
        bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
        require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Proof Invalid');
        
        _safeMint(msg.sender, _amount);
        minted[msg.sender] += 1;
    }

    function mint(uint _amount) external nonReentrant payable {
        require(status == 2, 'Public Sale Not Active');
        require(_amount <= maxPerTx, 'Amount Denied');
        require(tx.origin == msg.sender, 'Contract Denied');
        require(msg.value >= price * _amount, 'Ether Amount Denied');

        _safeMint(msg.sender, _amount);
        minted[msg.sender] += 1;
    }

    function withdraw() external nonReentrant payable onlyOwner {
        payable(vault).transfer(address(this).balance);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"_price","type":"uint256"},{"internalType":"address","name":"_vault","type":"address"},{"internalType":"uint256","name":"_maxPerTx","type":"uint256"},{"internalType":"string","name":"_tokenName","type":"string"},{"internalType":"string","name":"_tokenSymbol","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","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":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"minted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","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":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseTokenURI","type":"string"}],"name":"setBaseTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_price","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_status","type":"uint256"}],"name":"setStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_vault","type":"address"}],"name":"setVault","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"status","outputs":[{"internalType":"uint256","name":"","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":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","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":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vault","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"}]

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

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000001c4f6c1c7233f27ee9466e3932ce4ebc670e7371000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000000d46524f4e4b20205449434b4554000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003464b540000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _price (uint256): 0
Arg [1] : _vault (address): 0x1C4f6C1c7233f27ee9466e3932Ce4Ebc670E7371
Arg [2] : _maxPerTx (uint256): 1
Arg [3] : _tokenName (string): FRONK  TICKET
Arg [4] : _tokenSymbol (string): FKT

-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [1] : 0000000000000000000000001c4f6c1c7233f27ee9466e3932ce4ebc670e7371
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [3] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [4] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [5] : 000000000000000000000000000000000000000000000000000000000000000d
Arg [6] : 46524f4e4b20205449434b455400000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [8] : 464b540000000000000000000000000000000000000000000000000000000000

71664:2155:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53906:305;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57019:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58476:204;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58039:371;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53155:303;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71902:38;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71844:22;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59341:170;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;72896:390;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71755:25;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72376:122;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;73691:125;;;:::i;:::-;;59582:185;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56827:125;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72804:84;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;72709:87;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54275:206;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;30482:103;;;;;;;;;;;;;:::i;:::-;;72506:106;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;29834:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72620:81;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57188:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71820:17;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73294:389;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;58752:287;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59838:369;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57363:272;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71787:26;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59110:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;30740:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71873:20;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71728;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53906:305;54008:4;54060:25;54045:40;;;:11;:40;;;;:105;;;;54117:33;54102:48;;;:11;:48;;;;54045:105;:158;;;;54167:36;54191:11;54167:23;:36::i;:::-;54045:158;54025:178;;53906:305;;;:::o;57019:100::-;57073:13;57106:5;57099:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57019:100;:::o;58476:204::-;58544:7;58569:16;58577:7;58569;:16::i;:::-;58564:64;;58594:34;;;;;;;;;;;;;;58564:64;58648:15;:24;58664:7;58648:24;;;;;;;;;;;;;;;;;;;;;58641:31;;58476:204;;;:::o;58039:371::-;58112:13;58128:24;58144:7;58128:15;:24::i;:::-;58112:40;;58173:5;58167:11;;:2;:11;;;58163:48;;;58187:24;;;;;;;;;;;;;;58163:48;58244:5;58228:21;;:12;:10;:12::i;:::-;:21;;;;:63;;;;;58254:37;58271:5;58278:12;:10;:12::i;:::-;58254:16;:37::i;:::-;58253:38;58228:63;58224:138;;;58315:35;;;;;;;;;;;;;;58224:138;58374:28;58383:2;58387:7;58396:5;58374:8;:28::i;:::-;58101:309;58039:371;;:::o;53155:303::-;53199:7;53424:15;:13;:15::i;:::-;53409:12;;53393:13;;:28;:46;53386:53;;53155:303;:::o;71902:38::-;;;;;;;;;;;;;;;;;:::o;71844:22::-;;;;:::o;59341:170::-;59475:28;59485:4;59491:2;59495:7;59475:9;:28::i;:::-;59341:170;;;:::o;72896:390::-;11906:21;:19;:21::i;:::-;73025:1:::1;73015:6;;:11;73007:34;;;;;;;;;;;;:::i;:::-;;;;;;;;;73052:12;73094:10;73077:28;;;;;;;;:::i;:::-;;;;;;;;;;;;;73067:39;;;;;;73052:54;;73125:50;73144:12;;73125:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73158:10;;73170:4;73125:18;:50::i;:::-;73117:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;73214:30;73224:10;73236:7;73214:9;:30::i;:::-;73277:1;73255:6;:18;73262:10;73255:18;;;;;;;;;;;;;;;;:23;;;;;;;:::i;:::-;;;;;;;;72996:290;11950:20:::0;:18;:20::i;:::-;72896:390;;;:::o;71755:25::-;;;;:::o;72376:122::-;29720:13;:11;:13::i;:::-;72477::::1;;72462:12;:28;;;;;;;:::i;:::-;;72376:122:::0;;:::o;73691:125::-;11906:21;:19;:21::i;:::-;29720:13:::1;:11;:13::i;:::-;73770:5:::2;;;;;;;;;;;73762:23;;:46;73786:21;73762:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;11950:20:::0;:18;:20::i;:::-;73691:125::o;59582:185::-;59720:39;59737:4;59743:2;59747:7;59720:39;;;;;;;;;;;;:16;:39::i;:::-;59582:185;;;:::o;56827:125::-;56891:7;56918:21;56931:7;56918:12;:21::i;:::-;:26;;;56911:33;;56827:125;;;:::o;72804:84::-;29720:13;:11;:13::i;:::-;72874:6:::1;72866:5;;:14;;;;;;;;;;;;;;;;;;72804:84:::0;:::o;72709:87::-;29720:13;:11;:13::i;:::-;72781:7:::1;72772:6;:16;;;;72709:87:::0;:::o;54275:206::-;54339:7;54380:1;54363:19;;:5;:19;;;54359:60;;;54391:28;;;;;;;;;;;;;;54359:60;54445:12;:19;54458:5;54445:19;;;;;;;;;;;;;;;:27;;;;;;;;;;;;54437:36;;54430:43;;54275:206;;;:::o;30482:103::-;29720:13;:11;:13::i;:::-;30547:30:::1;30574:1;30547:18;:30::i;:::-;30482:103::o:0;72506:106::-;29720:13;:11;:13::i;:::-;72593:11:::1;72580:10;:24;;;;72506:106:::0;:::o;29834:87::-;29880:7;29907:6;;;;;;;;;;;29900:13;;29834:87;:::o;72620:81::-;29720:13;:11;:13::i;:::-;72687:6:::1;72679:5;:14;;;;72620:81:::0;:::o;57188:104::-;57244:13;57277:7;57270:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57188:104;:::o;71820:17::-;;;;:::o;73294:389::-;11906:21;:19;:21::i;:::-;73381:1:::1;73371:6;;:11;73363:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;73439:8;;73428:7;:19;;73420:45;;;;;;;;;;;;:::i;:::-;;;;;;;;;73497:10;73484:23;;:9;:23;;;73476:51;;;;;;;;;;;;:::i;:::-;;;;;;;;;73567:7;73559:5;;:15;;;;:::i;:::-;73546:9;:28;;73538:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;73611:30;73621:10;73633:7;73611:9;:30::i;:::-;73674:1;73652:6;:18;73659:10;73652:18;;;;;;;;;;;;;;;;:23;;;;;;;:::i;:::-;;;;;;;;11950:20:::0;:18;:20::i;:::-;73294:389;:::o;58752:287::-;58863:12;:10;:12::i;:::-;58851:24;;:8;:24;;;58847:54;;;58884:17;;;;;;;;;;;;;;58847:54;58959:8;58914:18;:32;58933:12;:10;:12::i;:::-;58914:32;;;;;;;;;;;;;;;:42;58947:8;58914:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;59012:8;58983:48;;58998:12;:10;:12::i;:::-;58983:48;;;59022:8;58983:48;;;;;;:::i;:::-;;;;;;;;58752:287;;:::o;59838:369::-;60005:28;60015:4;60021:2;60025:7;60005:9;:28::i;:::-;60048:15;:2;:13;;;:15::i;:::-;:76;;;;;60068:56;60099:4;60105:2;60109:7;60118:5;60068:30;:56::i;:::-;60067:57;60048:76;60044:156;;;60148:40;;;;;;;;;;;;;;60044:156;59838:369;;;;:::o;57363:272::-;57436:13;57467:16;57475:7;57467;:16::i;:::-;57462:59;;57492:29;;;;;;;;;;;;;;57462:59;57534:21;57558:10;:8;:10::i;:::-;57534:34;;57611:1;57592:7;57586:21;:26;;:41;;;;;;;;;;;;;;;;;57615:7;57586:41;57579:48;;;57363:272;;;:::o;71787:26::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;59110:164::-;59207:4;59231:18;:25;59250:5;59231:25;;;;;;;;;;;;;;;:35;59257:8;59231:35;;;;;;;;;;;;;;;;;;;;;;;;;59224:42;;59110:164;;;;:::o;30740:201::-;29720:13;:11;:13::i;:::-;30849:1:::1;30829:22;;:8;:22;;;;30821:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;30905:28;30924:8;30905:18;:28::i;:::-;30740:201:::0;:::o;71873:20::-;;;;:::o;71728:::-;;;;;;;;;;;;;:::o;43563:157::-;43648:4;43687:25;43672:40;;;:11;:40;;;;43665:47;;43563:157;;;:::o;60462:174::-;60519:4;60562:7;60543:15;:13;:15::i;:::-;:26;;:53;;;;;60583:13;;60573:7;:23;60543:53;:85;;;;;60601:11;:20;60613:7;60601:20;;;;;;;;;;;:27;;;;;;;;;;;;60600:28;60543:85;60536:92;;60462:174;;;:::o;28385:98::-;28438:7;28465:10;28458:17;;28385:98;:::o;68619:196::-;68761:2;68734:15;:24;68750:7;68734:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;68799:7;68795:2;68779:28;;68788:5;68779:28;;;;;;;;;;;;68619:196;;;:::o;52929:92::-;52985:7;52929:92;:::o;63562:2130::-;63677:35;63715:21;63728:7;63715:12;:21::i;:::-;63677:59;;63775:4;63753:26;;:13;:18;;;:26;;;63749:67;;63788:28;;;;;;;;;;;;;;63749:67;63829:22;63871:4;63855:20;;:12;:10;:12::i;:::-;:20;;;:73;;;;63892:36;63909:4;63915:12;:10;:12::i;:::-;63892:16;:36::i;:::-;63855:73;:126;;;;63969:12;:10;:12::i;:::-;63945:36;;:20;63957:7;63945:11;:20::i;:::-;:36;;;63855:126;63829:153;;64000:17;63995:66;;64026:35;;;;;;;;;;;;;;63995:66;64090:1;64076:16;;:2;:16;;;64072:52;;;64101:23;;;;;;;;;;;;;;64072:52;64137:43;64159:4;64165:2;64169:7;64178:1;64137:21;:43::i;:::-;64245:35;64262:1;64266:7;64275:4;64245:8;:35::i;:::-;64606:1;64576:12;:18;64589:4;64576:18;;;;;;;;;;;;;;;:26;;;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64650:1;64622:12;:16;64635:2;64622:16;;;;;;;;;;;;;;;:24;;;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64668:31;64702:11;:20;64714:7;64702:20;;;;;;;;;;;64668:54;;64753:2;64737:8;:13;;;:18;;;;;;;;;;;;;;;;;;64803:15;64770:8;:23;;;:49;;;;;;;;;;;;;;;;;;65071:19;65103:1;65093:7;:11;65071:33;;65119:31;65153:11;:24;65165:11;65153:24;;;;;;;;;;;65119:58;;65221:1;65196:27;;:8;:13;;;;;;;;;;;;:27;;;65192:384;;;65406:13;;65391:11;:28;65387:174;;65460:4;65444:8;:13;;;:20;;;;;;;;;;;;;;;;;;65513:13;:28;;;65487:8;:23;;;:54;;;;;;;;;;;;;;;;;;65387:174;65192:384;64551:1036;;;65623:7;65619:2;65604:27;;65613:4;65604:27;;;;;;;;;;;;65642:42;65663:4;65669:2;65673:7;65682:1;65642:20;:42::i;:::-;63666:2026;;63562:2130;;;:::o;11986:293::-;11388:1;12120:7;;:19;;12112:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;11388:1;12253:7;:18;;;;11986:293::o;1222:190::-;1347:4;1400;1371:25;1384:5;1391:4;1371:12;:25::i;:::-;:33;1364:40;;1222:190;;;;;:::o;60644:104::-;60713:27;60723:2;60727:8;60713:27;;;;;;;;;;;;:9;:27::i;:::-;60644:104;;:::o;12287:213::-;11344:1;12470:7;:22;;;;12287:213::o;29999:132::-;30074:12;:10;:12::i;:::-;30063:23;;:7;:5;:7::i;:::-;:23;;;30055:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;29999:132::o;55656:1109::-;55718:21;;:::i;:::-;55752:12;55767:7;55752:22;;55835:4;55816:15;:13;:15::i;:::-;:23;;:47;;;;;55850:13;;55843:4;:20;55816:47;55812:886;;;55884:31;55918:11;:17;55930:4;55918:17;;;;;;;;;;;55884:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55959:9;:16;;;55954:729;;56030:1;56004:28;;:9;:14;;;:28;;;56000:101;;56068:9;56061:16;;;;;;56000:101;56403:261;56410:4;56403:261;;;56443:6;;;;;;;;56488:11;:17;56500:4;56488:17;;;;;;;;;;;56476:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56562:1;56536:28;;:9;:14;;;:28;;;56532:109;;56604:9;56597:16;;;;;;56532:109;56403:261;;;55954:729;55865:833;55812:886;56726:31;;;;;;;;;;;;;;55656:1109;;;;:::o;31101:191::-;31175:16;31194:6;;;;;;;;;;;31175:25;;31220:8;31211:6;;:17;;;;;;;;;;;;;;;;;;31275:8;31244:40;;31265:8;31244:40;;;;;;;;;;;;31164:128;31101:191;:::o;32532:326::-;32592:4;32849:1;32827:7;:19;;;:23;32820:30;;32532:326;;;:::o;69307:667::-;69470:4;69507:2;69491:36;;;69528:12;:10;:12::i;:::-;69542:4;69548:7;69557:5;69491:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;69487:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69742:1;69725:6;:13;:18;69721:235;;;69771:40;;;;;;;;;;;;;;69721:235;69914:6;69908:13;69899:6;69895:2;69891:15;69884:38;69487:480;69620:45;;;69610:55;;;:6;:55;;;;69603:62;;;69307:667;;;;;;:::o;72255:113::-;72315:13;72348:12;72341:19;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72255:113;:::o;70622:159::-;;;;;:::o;71440:158::-;;;;;:::o;2089:296::-;2172:7;2192:20;2215:4;2192:27;;2235:9;2230:118;2254:5;:12;2250:1;:16;2230:118;;;2303:33;2313:12;2327:5;2333:1;2327:8;;;;;;;;:::i;:::-;;;;;;;;2303:9;:33::i;:::-;2288:48;;2268:3;;;;;:::i;:::-;;;;2230:118;;;;2365:12;2358:19;;;2089:296;;;;:::o;61111:163::-;61234:32;61240:2;61244:8;61254:5;61261:4;61234:5;:32::i;:::-;61111:163;;;:::o;9129:149::-;9192:7;9223:1;9219;:5;:51;;9250:20;9265:1;9268;9250:14;:20::i;:::-;9219:51;;;9227:20;9242:1;9245;9227:14;:20::i;:::-;9219:51;9212:58;;9129:149;;;;:::o;61533:1775::-;61672:20;61695:13;;61672:36;;61737:1;61723:16;;:2;:16;;;61719:48;;;61748:19;;;;;;;;;;;;;;61719:48;61794:1;61782:8;:13;61778:44;;;61804:18;;;;;;;;;;;;;;61778:44;61835:61;61865:1;61869:2;61873:12;61887:8;61835:21;:61::i;:::-;62208:8;62173:12;:16;62186:2;62173:16;;;;;;;;;;;;;;;:24;;;:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62272:8;62232:12;:16;62245:2;62232:16;;;;;;;;;;;;;;;:29;;;:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62331:2;62298:11;:25;62310:12;62298:25;;;;;;;;;;;:30;;;:35;;;;;;;;;;;;;;;;;;62398:15;62348:11;:25;62360:12;62348:25;;;;;;;;;;;:40;;;:66;;;;;;;;;;;;;;;;;;62431:20;62454:12;62431:35;;62481:11;62510:8;62495:12;:23;62481:37;;62539:4;:23;;;;;62547:15;:2;:13;;;:15::i;:::-;62539:23;62535:641;;;62583:314;62639:12;62635:2;62614:38;;62631:1;62614:38;;;;;;;;;;;;62680:69;62719:1;62723:2;62727:14;;;;;;62743:5;62680:30;:69::i;:::-;62675:174;;62785:40;;;;;;;;;;;;;;62675:174;62892:3;62876:12;:19;;62583:314;;62978:12;62961:13;;:29;62957:43;;62992:8;;;62957:43;62535:641;;;63041:120;63097:14;;;;;;63093:2;63072:40;;63089:1;63072:40;;;;;;;;;;;;63156:3;63140:12;:19;;63041:120;;62535:641;63206:12;63190:13;:28;;;;62148:1082;;63240:60;63269:1;63273:2;63277:12;63291:8;63240:20;:60::i;:::-;61661:1647;61533:1775;;;;:::o;9286:268::-;9354:13;9461:1;9455:4;9448:15;9490:1;9484:4;9477:15;9531:4;9525;9515:21;9506:30;;9286:268;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:410:1:-;84:5;109:65;125:48;166:6;125:48;:::i;:::-;109:65;:::i;:::-;100:74;;197:6;190:5;183:21;235:4;228:5;224:16;273:3;264:6;259:3;255:16;252:25;249:112;;;280:79;;:::i;:::-;249:112;370:41;404:6;399:3;394;370:41;:::i;:::-;90:327;7:410;;;;;:::o;423:139::-;469:5;507:6;494:20;485:29;;523:33;550:5;523:33;:::i;:::-;423:139;;;;:::o;585:568::-;658:8;668:6;718:3;711:4;703:6;699:17;695:27;685:122;;726:79;;:::i;:::-;685:122;839:6;826:20;816:30;;869:18;861:6;858:30;855:117;;;891:79;;:::i;:::-;855:117;1005:4;997:6;993:17;981:29;;1059:3;1051:4;1043:6;1039:17;1029:8;1025:32;1022:41;1019:128;;;1066:79;;:::i;:::-;1019:128;585:568;;;;;:::o;1159:133::-;1202:5;1240:6;1227:20;1218:29;;1256:30;1280:5;1256:30;:::i;:::-;1159:133;;;;:::o;1298:139::-;1344:5;1382:6;1369:20;1360:29;;1398:33;1425:5;1398:33;:::i;:::-;1298:139;;;;:::o;1443:137::-;1488:5;1526:6;1513:20;1504:29;;1542:32;1568:5;1542:32;:::i;:::-;1443:137;;;;:::o;1586:141::-;1642:5;1673:6;1667:13;1658:22;;1689:32;1715:5;1689:32;:::i;:::-;1586:141;;;;:::o;1746:338::-;1801:5;1850:3;1843:4;1835:6;1831:17;1827:27;1817:122;;1858:79;;:::i;:::-;1817:122;1975:6;1962:20;2000:78;2074:3;2066:6;2059:4;2051:6;2047:17;2000:78;:::i;:::-;1991:87;;1807:277;1746:338;;;;:::o;2104:553::-;2162:8;2172:6;2222:3;2215:4;2207:6;2203:17;2199:27;2189:122;;2230:79;;:::i;:::-;2189:122;2343:6;2330:20;2320:30;;2373:18;2365:6;2362:30;2359:117;;;2395:79;;:::i;:::-;2359:117;2509:4;2501:6;2497:17;2485:29;;2563:3;2555:4;2547:6;2543:17;2533:8;2529:32;2526:41;2523:128;;;2570:79;;:::i;:::-;2523:128;2104:553;;;;;:::o;2663:139::-;2709:5;2747:6;2734:20;2725:29;;2763:33;2790:5;2763:33;:::i;:::-;2663:139;;;;:::o;2808:329::-;2867:6;2916:2;2904:9;2895:7;2891:23;2887:32;2884:119;;;2922:79;;:::i;:::-;2884:119;3042:1;3067:53;3112:7;3103:6;3092:9;3088:22;3067:53;:::i;:::-;3057:63;;3013:117;2808:329;;;;:::o;3143:474::-;3211:6;3219;3268:2;3256:9;3247:7;3243:23;3239:32;3236:119;;;3274:79;;:::i;:::-;3236:119;3394:1;3419:53;3464:7;3455:6;3444:9;3440:22;3419:53;:::i;:::-;3409:63;;3365:117;3521:2;3547:53;3592:7;3583:6;3572:9;3568:22;3547:53;:::i;:::-;3537:63;;3492:118;3143:474;;;;;:::o;3623:619::-;3700:6;3708;3716;3765:2;3753:9;3744:7;3740:23;3736:32;3733:119;;;3771:79;;:::i;:::-;3733:119;3891:1;3916:53;3961:7;3952:6;3941:9;3937:22;3916:53;:::i;:::-;3906:63;;3862:117;4018:2;4044:53;4089:7;4080:6;4069:9;4065:22;4044:53;:::i;:::-;4034:63;;3989:118;4146:2;4172:53;4217:7;4208:6;4197:9;4193:22;4172:53;:::i;:::-;4162:63;;4117:118;3623:619;;;;;:::o;4248:943::-;4343:6;4351;4359;4367;4416:3;4404:9;4395:7;4391:23;4387:33;4384:120;;;4423:79;;:::i;:::-;4384:120;4543:1;4568:53;4613:7;4604:6;4593:9;4589:22;4568:53;:::i;:::-;4558:63;;4514:117;4670:2;4696:53;4741:7;4732:6;4721:9;4717:22;4696:53;:::i;:::-;4686:63;;4641:118;4798:2;4824:53;4869:7;4860:6;4849:9;4845:22;4824:53;:::i;:::-;4814:63;;4769:118;4954:2;4943:9;4939:18;4926:32;4985:18;4977:6;4974:30;4971:117;;;5007:79;;:::i;:::-;4971:117;5112:62;5166:7;5157:6;5146:9;5142:22;5112:62;:::i;:::-;5102:72;;4897:287;4248:943;;;;;;;:::o;5197:468::-;5262:6;5270;5319:2;5307:9;5298:7;5294:23;5290:32;5287:119;;;5325:79;;:::i;:::-;5287:119;5445:1;5470:53;5515:7;5506:6;5495:9;5491:22;5470:53;:::i;:::-;5460:63;;5416:117;5572:2;5598:50;5640:7;5631:6;5620:9;5616:22;5598:50;:::i;:::-;5588:60;;5543:115;5197:468;;;;;:::o;5671:474::-;5739:6;5747;5796:2;5784:9;5775:7;5771:23;5767:32;5764:119;;;5802:79;;:::i;:::-;5764:119;5922:1;5947:53;5992:7;5983:6;5972:9;5968:22;5947:53;:::i;:::-;5937:63;;5893:117;6049:2;6075:53;6120:7;6111:6;6100:9;6096:22;6075:53;:::i;:::-;6065:63;;6020:118;5671:474;;;;;:::o;6151:704::-;6246:6;6254;6262;6311:2;6299:9;6290:7;6286:23;6282:32;6279:119;;;6317:79;;:::i;:::-;6279:119;6465:1;6454:9;6450:17;6437:31;6495:18;6487:6;6484:30;6481:117;;;6517:79;;:::i;:::-;6481:117;6630:80;6702:7;6693:6;6682:9;6678:22;6630:80;:::i;:::-;6612:98;;;;6408:312;6759:2;6785:53;6830:7;6821:6;6810:9;6806:22;6785:53;:::i;:::-;6775:63;;6730:118;6151:704;;;;;:::o;6861:329::-;6920:6;6969:2;6957:9;6948:7;6944:23;6940:32;6937:119;;;6975:79;;:::i;:::-;6937:119;7095:1;7120:53;7165:7;7156:6;7145:9;7141:22;7120:53;:::i;:::-;7110:63;;7066:117;6861:329;;;;:::o;7196:327::-;7254:6;7303:2;7291:9;7282:7;7278:23;7274:32;7271:119;;;7309:79;;:::i;:::-;7271:119;7429:1;7454:52;7498:7;7489:6;7478:9;7474:22;7454:52;:::i;:::-;7444:62;;7400:116;7196:327;;;;:::o;7529:349::-;7598:6;7647:2;7635:9;7626:7;7622:23;7618:32;7615:119;;;7653:79;;:::i;:::-;7615:119;7773:1;7798:63;7853:7;7844:6;7833:9;7829:22;7798:63;:::i;:::-;7788:73;;7744:127;7529:349;;;;:::o;7884:529::-;7955:6;7963;8012:2;8000:9;7991:7;7987:23;7983:32;7980:119;;;8018:79;;:::i;:::-;7980:119;8166:1;8155:9;8151:17;8138:31;8196:18;8188:6;8185:30;8182:117;;;8218:79;;:::i;:::-;8182:117;8331:65;8388:7;8379:6;8368:9;8364:22;8331:65;:::i;:::-;8313:83;;;;8109:297;7884:529;;;;;:::o;8419:329::-;8478:6;8527:2;8515:9;8506:7;8502:23;8498:32;8495:119;;;8533:79;;:::i;:::-;8495:119;8653:1;8678:53;8723:7;8714:6;8703:9;8699:22;8678:53;:::i;:::-;8668:63;;8624:117;8419:329;;;;:::o;8754:118::-;8841:24;8859:5;8841:24;:::i;:::-;8836:3;8829:37;8754:118;;:::o;8878:157::-;8983:45;9003:24;9021:5;9003:24;:::i;:::-;8983:45;:::i;:::-;8978:3;8971:58;8878:157;;:::o;9041:109::-;9122:21;9137:5;9122:21;:::i;:::-;9117:3;9110:34;9041:109;;:::o;9156:118::-;9243:24;9261:5;9243:24;:::i;:::-;9238:3;9231:37;9156:118;;:::o;9280:360::-;9366:3;9394:38;9426:5;9394:38;:::i;:::-;9448:70;9511:6;9506:3;9448:70;:::i;:::-;9441:77;;9527:52;9572:6;9567:3;9560:4;9553:5;9549:16;9527:52;:::i;:::-;9604:29;9626:6;9604:29;:::i;:::-;9599:3;9595:39;9588:46;;9370:270;9280:360;;;;:::o;9646:364::-;9734:3;9762:39;9795:5;9762:39;:::i;:::-;9817:71;9881:6;9876:3;9817:71;:::i;:::-;9810:78;;9897:52;9942:6;9937:3;9930:4;9923:5;9919:16;9897:52;:::i;:::-;9974:29;9996:6;9974:29;:::i;:::-;9969:3;9965:39;9958:46;;9738:272;9646:364;;;;:::o;10016:366::-;10158:3;10179:67;10243:2;10238:3;10179:67;:::i;:::-;10172:74;;10255:93;10344:3;10255:93;:::i;:::-;10373:2;10368:3;10364:12;10357:19;;10016:366;;;:::o;10388:::-;10530:3;10551:67;10615:2;10610:3;10551:67;:::i;:::-;10544:74;;10627:93;10716:3;10627:93;:::i;:::-;10745:2;10740:3;10736:12;10729:19;;10388:366;;;:::o;10760:::-;10902:3;10923:67;10987:2;10982:3;10923:67;:::i;:::-;10916:74;;10999:93;11088:3;10999:93;:::i;:::-;11117:2;11112:3;11108:12;11101:19;;10760:366;;;:::o;11132:::-;11274:3;11295:67;11359:2;11354:3;11295:67;:::i;:::-;11288:74;;11371:93;11460:3;11371:93;:::i;:::-;11489:2;11484:3;11480:12;11473:19;;11132:366;;;:::o;11504:::-;11646:3;11667:67;11731:2;11726:3;11667:67;:::i;:::-;11660:74;;11743:93;11832:3;11743:93;:::i;:::-;11861:2;11856:3;11852:12;11845:19;;11504:366;;;:::o;11876:::-;12018:3;12039:67;12103:2;12098:3;12039:67;:::i;:::-;12032:74;;12115:93;12204:3;12115:93;:::i;:::-;12233:2;12228:3;12224:12;12217:19;;11876:366;;;:::o;12248:::-;12390:3;12411:67;12475:2;12470:3;12411:67;:::i;:::-;12404:74;;12487:93;12576:3;12487:93;:::i;:::-;12605:2;12600:3;12596:12;12589:19;;12248:366;;;:::o;12620:::-;12762:3;12783:67;12847:2;12842:3;12783:67;:::i;:::-;12776:74;;12859:93;12948:3;12859:93;:::i;:::-;12977:2;12972:3;12968:12;12961:19;;12620:366;;;:::o;12992:::-;13134:3;13155:67;13219:2;13214:3;13155:67;:::i;:::-;13148:74;;13231:93;13320:3;13231:93;:::i;:::-;13349:2;13344:3;13340:12;13333:19;;12992:366;;;:::o;13364:118::-;13451:24;13469:5;13451:24;:::i;:::-;13446:3;13439:37;13364:118;;:::o;13488:256::-;13600:3;13615:75;13686:3;13677:6;13615:75;:::i;:::-;13715:2;13710:3;13706:12;13699:19;;13735:3;13728:10;;13488:256;;;;:::o;13750:222::-;13843:4;13881:2;13870:9;13866:18;13858:26;;13894:71;13962:1;13951:9;13947:17;13938:6;13894:71;:::i;:::-;13750:222;;;;:::o;13978:640::-;14173:4;14211:3;14200:9;14196:19;14188:27;;14225:71;14293:1;14282:9;14278:17;14269:6;14225:71;:::i;:::-;14306:72;14374:2;14363:9;14359:18;14350:6;14306:72;:::i;:::-;14388;14456:2;14445:9;14441:18;14432:6;14388:72;:::i;:::-;14507:9;14501:4;14497:20;14492:2;14481:9;14477:18;14470:48;14535:76;14606:4;14597:6;14535:76;:::i;:::-;14527:84;;13978:640;;;;;;;:::o;14624:210::-;14711:4;14749:2;14738:9;14734:18;14726:26;;14762:65;14824:1;14813:9;14809:17;14800:6;14762:65;:::i;:::-;14624:210;;;;:::o;14840:222::-;14933:4;14971:2;14960:9;14956:18;14948:26;;14984:71;15052:1;15041:9;15037:17;15028:6;14984:71;:::i;:::-;14840:222;;;;:::o;15068:313::-;15181:4;15219:2;15208:9;15204:18;15196:26;;15268:9;15262:4;15258:20;15254:1;15243:9;15239:17;15232:47;15296:78;15369:4;15360:6;15296:78;:::i;:::-;15288:86;;15068:313;;;;:::o;15387:419::-;15553:4;15591:2;15580:9;15576:18;15568:26;;15640:9;15634:4;15630:20;15626:1;15615:9;15611:17;15604:47;15668:131;15794:4;15668:131;:::i;:::-;15660:139;;15387:419;;;:::o;15812:::-;15978:4;16016:2;16005:9;16001:18;15993:26;;16065:9;16059:4;16055:20;16051:1;16040:9;16036:17;16029:47;16093:131;16219:4;16093:131;:::i;:::-;16085:139;;15812:419;;;:::o;16237:::-;16403:4;16441:2;16430:9;16426:18;16418:26;;16490:9;16484:4;16480:20;16476:1;16465:9;16461:17;16454:47;16518:131;16644:4;16518:131;:::i;:::-;16510:139;;16237:419;;;:::o;16662:::-;16828:4;16866:2;16855:9;16851:18;16843:26;;16915:9;16909:4;16905:20;16901:1;16890:9;16886:17;16879:47;16943:131;17069:4;16943:131;:::i;:::-;16935:139;;16662:419;;;:::o;17087:::-;17253:4;17291:2;17280:9;17276:18;17268:26;;17340:9;17334:4;17330:20;17326:1;17315:9;17311:17;17304:47;17368:131;17494:4;17368:131;:::i;:::-;17360:139;;17087:419;;;:::o;17512:::-;17678:4;17716:2;17705:9;17701:18;17693:26;;17765:9;17759:4;17755:20;17751:1;17740:9;17736:17;17729:47;17793:131;17919:4;17793:131;:::i;:::-;17785:139;;17512:419;;;:::o;17937:::-;18103:4;18141:2;18130:9;18126:18;18118:26;;18190:9;18184:4;18180:20;18176:1;18165:9;18161:17;18154:47;18218:131;18344:4;18218:131;:::i;:::-;18210:139;;17937:419;;;:::o;18362:::-;18528:4;18566:2;18555:9;18551:18;18543:26;;18615:9;18609:4;18605:20;18601:1;18590:9;18586:17;18579:47;18643:131;18769:4;18643:131;:::i;:::-;18635:139;;18362:419;;;:::o;18787:::-;18953:4;18991:2;18980:9;18976:18;18968:26;;19040:9;19034:4;19030:20;19026:1;19015:9;19011:17;19004:47;19068:131;19194:4;19068:131;:::i;:::-;19060:139;;18787:419;;;:::o;19212:222::-;19305:4;19343:2;19332:9;19328:18;19320:26;;19356:71;19424:1;19413:9;19409:17;19400:6;19356:71;:::i;:::-;19212:222;;;;:::o;19440:129::-;19474:6;19501:20;;:::i;:::-;19491:30;;19530:33;19558:4;19550:6;19530:33;:::i;:::-;19440:129;;;:::o;19575:75::-;19608:6;19641:2;19635:9;19625:19;;19575:75;:::o;19656:307::-;19717:4;19807:18;19799:6;19796:30;19793:56;;;19829:18;;:::i;:::-;19793:56;19867:29;19889:6;19867:29;:::i;:::-;19859:37;;19951:4;19945;19941:15;19933:23;;19656:307;;;:::o;19969:98::-;20020:6;20054:5;20048:12;20038:22;;19969:98;;;:::o;20073:99::-;20125:6;20159:5;20153:12;20143:22;;20073:99;;;:::o;20178:168::-;20261:11;20295:6;20290:3;20283:19;20335:4;20330:3;20326:14;20311:29;;20178:168;;;;:::o;20352:169::-;20436:11;20470:6;20465:3;20458:19;20510:4;20505:3;20501:14;20486:29;;20352:169;;;;:::o;20527:305::-;20567:3;20586:20;20604:1;20586:20;:::i;:::-;20581:25;;20620:20;20638:1;20620:20;:::i;:::-;20615:25;;20774:1;20706:66;20702:74;20699:1;20696:81;20693:107;;;20780:18;;:::i;:::-;20693:107;20824:1;20821;20817:9;20810:16;;20527:305;;;;:::o;20838:348::-;20878:7;20901:20;20919:1;20901:20;:::i;:::-;20896:25;;20935:20;20953:1;20935:20;:::i;:::-;20930:25;;21123:1;21055:66;21051:74;21048:1;21045:81;21040:1;21033:9;21026:17;21022:105;21019:131;;;21130:18;;:::i;:::-;21019:131;21178:1;21175;21171:9;21160:20;;20838:348;;;;:::o;21192:96::-;21229:7;21258:24;21276:5;21258:24;:::i;:::-;21247:35;;21192:96;;;:::o;21294:90::-;21328:7;21371:5;21364:13;21357:21;21346:32;;21294:90;;;:::o;21390:77::-;21427:7;21456:5;21445:16;;21390:77;;;:::o;21473:149::-;21509:7;21549:66;21542:5;21538:78;21527:89;;21473:149;;;:::o;21628:126::-;21665:7;21705:42;21698:5;21694:54;21683:65;;21628:126;;;:::o;21760:77::-;21797:7;21826:5;21815:16;;21760:77;;;:::o;21843:154::-;21927:6;21922:3;21917;21904:30;21989:1;21980:6;21975:3;21971:16;21964:27;21843:154;;;:::o;22003:307::-;22071:1;22081:113;22095:6;22092:1;22089:13;22081:113;;;22180:1;22175:3;22171:11;22165:18;22161:1;22156:3;22152:11;22145:39;22117:2;22114:1;22110:10;22105:15;;22081:113;;;22212:6;22209:1;22206:13;22203:101;;;22292:1;22283:6;22278:3;22274:16;22267:27;22203:101;22052:258;22003:307;;;:::o;22316:320::-;22360:6;22397:1;22391:4;22387:12;22377:22;;22444:1;22438:4;22434:12;22465:18;22455:81;;22521:4;22513:6;22509:17;22499:27;;22455:81;22583:2;22575:6;22572:14;22552:18;22549:38;22546:84;;;22602:18;;:::i;:::-;22546:84;22367:269;22316:320;;;:::o;22642:281::-;22725:27;22747:4;22725:27;:::i;:::-;22717:6;22713:40;22855:6;22843:10;22840:22;22819:18;22807:10;22804:34;22801:62;22798:88;;;22866:18;;:::i;:::-;22798:88;22906:10;22902:2;22895:22;22685:238;22642:281;;:::o;22929:233::-;22968:3;22991:24;23009:5;22991:24;:::i;:::-;22982:33;;23037:66;23030:5;23027:77;23024:103;;;23107:18;;:::i;:::-;23024:103;23154:1;23147:5;23143:13;23136:20;;22929:233;;;:::o;23168:100::-;23207:7;23236:26;23256:5;23236:26;:::i;:::-;23225:37;;23168:100;;;:::o;23274:94::-;23313:7;23342:20;23356:5;23342:20;:::i;:::-;23331:31;;23274:94;;;:::o;23374:180::-;23422:77;23419:1;23412:88;23519:4;23516:1;23509:15;23543:4;23540:1;23533:15;23560:180;23608:77;23605:1;23598:88;23705:4;23702:1;23695:15;23729:4;23726:1;23719:15;23746:180;23794:77;23791:1;23784:88;23891:4;23888:1;23881:15;23915:4;23912:1;23905:15;23932:180;23980:77;23977:1;23970:88;24077:4;24074:1;24067:15;24101:4;24098:1;24091:15;24118:117;24227:1;24224;24217:12;24241:117;24350:1;24347;24340:12;24364:117;24473:1;24470;24463:12;24487:117;24596:1;24593;24586:12;24610:117;24719:1;24716;24709:12;24733:117;24842:1;24839;24832:12;24856:102;24897:6;24948:2;24944:7;24939:2;24932:5;24928:14;24924:28;24914:38;;24856:102;;;:::o;24964:94::-;24997:8;25045:5;25041:2;25037:14;25016:35;;24964:94;;;:::o;25064:225::-;25204:34;25200:1;25192:6;25188:14;25181:58;25273:8;25268:2;25260:6;25256:15;25249:33;25064:225;:::o;25295:165::-;25435:17;25431:1;25423:6;25419:14;25412:41;25295:165;:::o;25466:160::-;25606:12;25602:1;25594:6;25590:14;25583:36;25466:160;:::o;25632:172::-;25772:24;25768:1;25760:6;25756:14;25749:48;25632:172;:::o;25810:163::-;25950:15;25946:1;25938:6;25934:14;25927:39;25810:163;:::o;25979:182::-;26119:34;26115:1;26107:6;26103:14;26096:58;25979:182;:::o;26167:163::-;26307:15;26303:1;26295:6;26291:14;26284:39;26167:163;:::o;26336:169::-;26476:21;26472:1;26464:6;26460:14;26453:45;26336:169;:::o;26511:181::-;26651:33;26647:1;26639:6;26635:14;26628:57;26511:181;:::o;26698:122::-;26771:24;26789:5;26771:24;:::i;:::-;26764:5;26761:35;26751:63;;26810:1;26807;26800:12;26751:63;26698:122;:::o;26826:116::-;26896:21;26911:5;26896:21;:::i;:::-;26889:5;26886:32;26876:60;;26932:1;26929;26922:12;26876:60;26826:116;:::o;26948:122::-;27021:24;27039:5;27021:24;:::i;:::-;27014:5;27011:35;27001:63;;27060:1;27057;27050:12;27001:63;26948:122;:::o;27076:120::-;27148:23;27165:5;27148:23;:::i;:::-;27141:5;27138:34;27128:62;;27186:1;27183;27176:12;27128:62;27076:120;:::o;27202:122::-;27275:24;27293:5;27275:24;:::i;:::-;27268:5;27265:35;27255:63;;27314:1;27311;27304:12;27255:63;27202:122;:::o

ipfs://050bd4c86b493746a4e25fe9285fa0cfd09dc372a1de3d24e47a05f2b5feed33