Token

Bitcoin Ape Punks (BAP)

ERC-721

Overview

Max Total Supply

10,000 BAP

Holders

3,493

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x873b0ba7d721edb1cdef6b5a48efe1b6a2b925a0

Filtered by Token Holder

0x99CB34E4291e16bc625B14332D45EdfB475aBb60

karbonio.eth

Balance

2 BAP

0x99cb34e4291e16bc625b14332d45edfb475abb60

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

BitcoinApePunks

Compiler Version

v0.8.19+commit.7dd6d404

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-03-15
*/

/**
 *Submitted for verification at Etherscan.io on 2022-12-28
*/

// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/utils/structs/EnumerableSet.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// File: contracts/IOperatorFilterRegistry.sol


pragma solidity ^0.8.13;

interface IOperatorFilterRegistry {
    function isOperatorAllowed(address registrant, address operator) external view returns (bool);
    function register(address registrant) external;
    function registerAndSubscribe(address registrant, address subscription) external;
    function registerAndCopyEntries(address registrant, address registrantToCopy) external;
    function unregister(address addr) external;
    function updateOperator(address registrant, address operator, bool filtered) external;
    function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
    function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
    function subscribe(address registrant, address registrantToSubscribe) external;
    function unsubscribe(address registrant, bool copyExistingEntries) external;
    function subscriptionOf(address addr) external returns (address registrant);
    function subscribers(address registrant) external returns (address[] memory);
    function subscriberAt(address registrant, uint256 index) external returns (address);
    function copyEntriesOf(address registrant, address registrantToCopy) external;
    function isOperatorFiltered(address registrant, address operator) external returns (bool);
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
    function filteredOperators(address addr) external returns (address[] memory);
    function filteredCodeHashes(address addr) external returns (bytes32[] memory);
    function filteredOperatorAt(address registrant, uint256 index) external returns (address);
    function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
    function isRegistered(address addr) external returns (bool);
    function codeHashOf(address addr) external returns (bytes32);
}
// File: contracts/OperatorFilterer.sol


// OpenZeppelin Contracts (last updated v4.8.0) (access/Ownable2Step.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module which provides 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} and {acceptOwnership}.
 *
 * This module is used through inheritance. It will make available all functions
 * from parent (Ownable).
 */



pragma solidity ^0.8.13;

/**
 * @title  OwnedRegistrant
 * @notice Ownable contract that registers itself with the OperatorFilterRegistry and administers its own entries,
 *         to facilitate a subscription whose ownership can be transferred.
 */

pragma solidity ^0.8.13;

contract OperatorFilterRegistryErrorsAndEvents {
    error CannotFilterEOAs();
    error AddressAlreadyFiltered(address operator);
    error AddressNotFiltered(address operator);
    error CodeHashAlreadyFiltered(bytes32 codeHash);
    error CodeHashNotFiltered(bytes32 codeHash);
    error OnlyAddressOrOwner();
    error NotRegistered(address registrant);
    error AlreadyRegistered();
    error AlreadySubscribed(address subscription);
    error NotSubscribed();
    error CannotUpdateWhileSubscribed(address subscription);
    error CannotSubscribeToSelf();
    error CannotSubscribeToZeroAddress();
    error NotOwnable();
    error AddressFiltered(address filtered);
    error CodeHashFiltered(address account, bytes32 codeHash);
    error CannotSubscribeToRegistrantWithSubscription(address registrant);
    error CannotCopyFromSelf();

    event RegistrationUpdated(address indexed registrant, bool indexed registered);
    event OperatorUpdated(address indexed registrant, address indexed operator, bool indexed filtered);
    event OperatorsUpdated(address indexed registrant, address[] operators, bool indexed filtered);
    event CodeHashUpdated(address indexed registrant, bytes32 indexed codeHash, bool indexed filtered);
    event CodeHashesUpdated(address indexed registrant, bytes32[] codeHashes, bool indexed filtered);
    event SubscriptionUpdated(address indexed registrant, address indexed subscription, bool indexed subscribed);
}

pragma solidity ^0.8.13;

/**
 * @title  OperatorFilterRegistry
 * @notice Borrows heavily from the QQL BlacklistOperatorFilter contract:
 *         https://github.com/qql-art/contracts/blob/main/contracts/BlacklistOperatorFilter.sol
 * @notice This contracts allows tokens or token owners to register specific addresses or codeHashes that may be
 * *       restricted according to the isOperatorAllowed function.
 */
contract OperatorFilterRegistry is IOperatorFilterRegistry, OperatorFilterRegistryErrorsAndEvents {
    using EnumerableSet for EnumerableSet.AddressSet;
    using EnumerableSet for EnumerableSet.Bytes32Set;

    /// @dev initialized accounts have a nonzero codehash (see https://eips.ethereum.org/EIPS/eip-1052)
    /// Note that this will also be a smart contract's codehash when making calls from its constructor.
    bytes32 constant EOA_CODEHASH = keccak256("");

    mapping(address => EnumerableSet.AddressSet) private _filteredOperators;
    mapping(address => EnumerableSet.Bytes32Set) private _filteredCodeHashes;
    mapping(address => address) private _registrations;
    mapping(address => EnumerableSet.AddressSet) private _subscribers;

    /**
     * @notice restricts method caller to the address or EIP-173 "owner()"
     */
    modifier onlyAddressOrOwner(address addr) {
        if (msg.sender != addr) {
            try Ownable(addr).owner() returns (address owner) {
                if (msg.sender != owner) {
                    revert OnlyAddressOrOwner();
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert NotOwnable();
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
        _;
    }

    /**
     * @notice Returns true if operator is not filtered for a given token, either by address or codeHash. Also returns
     *         true if supplied registrant address is not registered.
     */
    function isOperatorAllowed(address registrant, address operator) external view returns (bool) {
        address registration = _registrations[registrant];
        if (registration != address(0)) {
            EnumerableSet.AddressSet storage filteredOperatorsRef;
            EnumerableSet.Bytes32Set storage filteredCodeHashesRef;

            filteredOperatorsRef = _filteredOperators[registration];
            filteredCodeHashesRef = _filteredCodeHashes[registration];

            if (filteredOperatorsRef.contains(operator)) {
                revert AddressFiltered(operator);
            }
            if (operator.code.length > 0) {
                bytes32 codeHash = operator.codehash;
                if (filteredCodeHashesRef.contains(codeHash)) {
                    revert CodeHashFiltered(operator, codeHash);
                }
            }
        }
        return true;
    }

    //////////////////
    // AUTH METHODS //
    //////////////////

    /**
     * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner.
     */
    function register(address registrant) external onlyAddressOrOwner(registrant) {
        if (_registrations[registrant] != address(0)) {
            revert AlreadyRegistered();
        }
        _registrations[registrant] = registrant;
        emit RegistrationUpdated(registrant, true);
    }

    /**
     * @notice Unregisters an address with the registry and removes its subscription. May be called by address itself or by EIP-173 owner.
     *         Note that this does not remove any filtered addresses or codeHashes.
     *         Also note that any subscriptions to this registrant will still be active and follow the existing filtered addresses and codehashes.
     */
    function unregister(address registrant) external onlyAddressOrOwner(registrant) {
        address registration = _registrations[registrant];
        if (registration == address(0)) {
            revert NotRegistered(registrant);
        }
        if (registration != registrant) {
            _subscribers[registration].remove(registrant);
            emit SubscriptionUpdated(registrant, registration, false);
        }
        _registrations[registrant] = address(0);
        emit RegistrationUpdated(registrant, false);
    }

    /**
     * @notice Registers an address with the registry and "subscribes" to another address's filtered operators and codeHashes.
     */
    function registerAndSubscribe(address registrant, address subscription) external onlyAddressOrOwner(registrant) {
        address registration = _registrations[registrant];
        if (registration != address(0)) {
            revert AlreadyRegistered();
        }
        if (registrant == subscription) {
            revert CannotSubscribeToSelf();
        }
        address subscriptionRegistration = _registrations[subscription];
        if (subscriptionRegistration == address(0)) {
            revert NotRegistered(subscription);
        }
        if (subscriptionRegistration != subscription) {
            revert CannotSubscribeToRegistrantWithSubscription(subscription);
        }

        _registrations[registrant] = subscription;
        _subscribers[subscription].add(registrant);
        emit RegistrationUpdated(registrant, true);
        emit SubscriptionUpdated(registrant, subscription, true);
    }

    /**
     * @notice Registers an address with the registry and copies the filtered operators and codeHashes from another
     *         address without subscribing.
     */
    function registerAndCopyEntries(address registrant, address registrantToCopy)
        external
        onlyAddressOrOwner(registrant)
    {
        if (registrantToCopy == registrant) {
            revert CannotCopyFromSelf();
        }
        address registration = _registrations[registrant];
        if (registration != address(0)) {
            revert AlreadyRegistered();
        }
        address registrantRegistration = _registrations[registrantToCopy];
        if (registrantRegistration == address(0)) {
            revert NotRegistered(registrantToCopy);
        }
        _registrations[registrant] = registrant;
        emit RegistrationUpdated(registrant, true);
        _copyEntries(registrant, registrantToCopy);
    }

    /**
     * @notice Update an operator address for a registered address - when filtered is true, the operator is filtered.
     */
    function updateOperator(address registrant, address operator, bool filtered)
        external
        onlyAddressOrOwner(registrant)
    {
        address registration = _registrations[registrant];
        if (registration == address(0)) {
            revert NotRegistered(registrant);
        }
        if (registration != registrant) {
            revert CannotUpdateWhileSubscribed(registration);
        }
        EnumerableSet.AddressSet storage filteredOperatorsRef = _filteredOperators[registrant];

        if (!filtered) {
            bool removed = filteredOperatorsRef.remove(operator);
            if (!removed) {
                revert AddressNotFiltered(operator);
            }
        } else {
            bool added = filteredOperatorsRef.add(operator);
            if (!added) {
                revert AddressAlreadyFiltered(operator);
            }
        }
        emit OperatorUpdated(registrant, operator, filtered);
    }

    /**
     * @notice Update a codeHash for a registered address - when filtered is true, the codeHash is filtered.
     */
    function updateCodeHash(address registrant, bytes32 codeHash, bool filtered)
        external
        onlyAddressOrOwner(registrant)
    {
        if (codeHash == EOA_CODEHASH) {
            revert CannotFilterEOAs();
        }
        address registration = _registrations[registrant];
        if (registration == address(0)) {
            revert NotRegistered(registrant);
        }
        if (registration != registrant) {
            revert CannotUpdateWhileSubscribed(registration);
        }
        EnumerableSet.Bytes32Set storage filteredCodeHashesRef = _filteredCodeHashes[registrant];

        if (!filtered) {
            bool removed = filteredCodeHashesRef.remove(codeHash);
            if (!removed) {
                revert CodeHashNotFiltered(codeHash);
            }
        } else {
            bool added = filteredCodeHashesRef.add(codeHash);
            if (!added) {
                revert CodeHashAlreadyFiltered(codeHash);
            }
        }
        emit CodeHashUpdated(registrant, codeHash, filtered);
    }

    /**
     * @notice Update multiple operators for a registered address - when filtered is true, the operators will be filtered. Reverts on duplicates.
     */
    function updateOperators(address registrant, address[] calldata operators, bool filtered)
        external
        onlyAddressOrOwner(registrant)
    {
        address registration = _registrations[registrant];
        if (registration == address(0)) {
            revert NotRegistered(registrant);
        }
        if (registration != registrant) {
            revert CannotUpdateWhileSubscribed(registration);
        }
        EnumerableSet.AddressSet storage filteredOperatorsRef = _filteredOperators[registrant];
        uint256 operatorsLength = operators.length;
        unchecked {
            if (!filtered) {
                for (uint256 i = 0; i < operatorsLength; ++i) {
                    address operator = operators[i];
                    bool removed = filteredOperatorsRef.remove(operator);
                    if (!removed) {
                        revert AddressNotFiltered(operator);
                    }
                }
            } else {
                for (uint256 i = 0; i < operatorsLength; ++i) {
                    address operator = operators[i];
                    bool added = filteredOperatorsRef.add(operator);
                    if (!added) {
                        revert AddressAlreadyFiltered(operator);
                    }
                }
            }
        }
        emit OperatorsUpdated(registrant, operators, filtered);
    }

    /**
     * @notice Update multiple codeHashes for a registered address - when filtered is true, the codeHashes will be filtered. Reverts on duplicates.
     */
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered)
        external
        onlyAddressOrOwner(registrant)
    {
        address registration = _registrations[registrant];
        if (registration == address(0)) {
            revert NotRegistered(registrant);
        }
        if (registration != registrant) {
            revert CannotUpdateWhileSubscribed(registration);
        }
        EnumerableSet.Bytes32Set storage filteredCodeHashesRef = _filteredCodeHashes[registrant];
        uint256 codeHashesLength = codeHashes.length;
        unchecked {
            if (!filtered) {
                for (uint256 i = 0; i < codeHashesLength; ++i) {
                    bytes32 codeHash = codeHashes[i];
                    bool removed = filteredCodeHashesRef.remove(codeHash);
                    if (!removed) {
                        revert CodeHashNotFiltered(codeHash);
                    }
                }
            } else {
                for (uint256 i = 0; i < codeHashesLength; ++i) {
                    bytes32 codeHash = codeHashes[i];
                    if (codeHash == EOA_CODEHASH) {
                        revert CannotFilterEOAs();
                    }
                    bool added = filteredCodeHashesRef.add(codeHash);
                    if (!added) {
                        revert CodeHashAlreadyFiltered(codeHash);
                    }
                }
            }
        }
        emit CodeHashesUpdated(registrant, codeHashes, filtered);
    }

    /**
     * @notice Subscribe an address to another registrant's filtered operators and codeHashes. Will remove previous
     *         subscription if present.
     *         Note that accounts with subscriptions may go on to subscribe to other accounts - in this case,
     *         subscriptions will not be forwarded. Instead the former subscription's existing entries will still be
     *         used.
     */
    function subscribe(address registrant, address newSubscription) external onlyAddressOrOwner(registrant) {
        if (registrant == newSubscription) {
            revert CannotSubscribeToSelf();
        }
        if (newSubscription == address(0)) {
            revert CannotSubscribeToZeroAddress();
        }
        address registration = _registrations[registrant];
        if (registration == address(0)) {
            revert NotRegistered(registrant);
        }
        if (registration == newSubscription) {
            revert AlreadySubscribed(newSubscription);
        }
        address newSubscriptionRegistration = _registrations[newSubscription];
        if (newSubscriptionRegistration == address(0)) {
            revert NotRegistered(newSubscription);
        }
        if (newSubscriptionRegistration != newSubscription) {
            revert CannotSubscribeToRegistrantWithSubscription(newSubscription);
        }

        if (registration != registrant) {
            _subscribers[registration].remove(registrant);
            emit SubscriptionUpdated(registrant, registration, false);
        }
        _registrations[registrant] = newSubscription;
        _subscribers[newSubscription].add(registrant);
        emit SubscriptionUpdated(registrant, newSubscription, true);
    }

    /**
     * @notice Unsubscribe an address from its current subscribed registrant, and optionally copy its filtered operators and codeHashes.
     */
    function unsubscribe(address registrant, bool copyExistingEntries) external onlyAddressOrOwner(registrant) {
        address registration = _registrations[registrant];
        if (registration == address(0)) {
            revert NotRegistered(registrant);
        }
        if (registration == registrant) {
            revert NotSubscribed();
        }
        _subscribers[registration].remove(registrant);
        _registrations[registrant] = registrant;
        emit SubscriptionUpdated(registrant, registration, false);
        if (copyExistingEntries) {
            _copyEntries(registrant, registration);
        }
    }

    /**
     * @notice Copy filtered operators and codeHashes from a different registrantToCopy to addr.
     */
    function copyEntriesOf(address registrant, address registrantToCopy) external onlyAddressOrOwner(registrant) {
        if (registrant == registrantToCopy) {
            revert CannotCopyFromSelf();
        }
        address registration = _registrations[registrant];
        if (registration == address(0)) {
            revert NotRegistered(registrant);
        }
        if (registration != registrant) {
            revert CannotUpdateWhileSubscribed(registration);
        }
        address registrantRegistration = _registrations[registrantToCopy];
        if (registrantRegistration == address(0)) {
            revert NotRegistered(registrantToCopy);
        }
        _copyEntries(registrant, registrantToCopy);
    }

    /// @dev helper to copy entries from registrantToCopy to registrant and emit events
    function _copyEntries(address registrant, address registrantToCopy) private {
        EnumerableSet.AddressSet storage filteredOperatorsRef = _filteredOperators[registrantToCopy];
        EnumerableSet.Bytes32Set storage filteredCodeHashesRef = _filteredCodeHashes[registrantToCopy];
        uint256 filteredOperatorsLength = filteredOperatorsRef.length();
        uint256 filteredCodeHashesLength = filteredCodeHashesRef.length();
        unchecked {
            for (uint256 i = 0; i < filteredOperatorsLength; ++i) {
                address operator = filteredOperatorsRef.at(i);
                bool added = _filteredOperators[registrant].add(operator);
                if (added) {
                    emit OperatorUpdated(registrant, operator, true);
                }
            }
            for (uint256 i = 0; i < filteredCodeHashesLength; ++i) {
                bytes32 codehash = filteredCodeHashesRef.at(i);
                bool added = _filteredCodeHashes[registrant].add(codehash);
                if (added) {
                    emit CodeHashUpdated(registrant, codehash, true);
                }
            }
        }
    }

    //////////////////
    // VIEW METHODS //
    //////////////////

    /**
     * @notice Get the subscription address of a given registrant, if any.
     */
    function subscriptionOf(address registrant) external view returns (address subscription) {
        subscription = _registrations[registrant];
        if (subscription == address(0)) {
            revert NotRegistered(registrant);
        } else if (subscription == registrant) {
            subscription = address(0);
        }
    }

    /**
     * @notice Get the set of addresses subscribed to a given registrant.
     *         Note that order is not guaranteed as updates are made.
     */
    function subscribers(address registrant) external view returns (address[] memory) {
        return _subscribers[registrant].values();
    }

    /**
     * @notice Get the subscriber at a given index in the set of addresses subscribed to a given registrant.
     *         Note that order is not guaranteed as updates are made.
     */
    function subscriberAt(address registrant, uint256 index) external view returns (address) {
        return _subscribers[registrant].at(index);
    }

    /**
     * @notice Returns true if operator is filtered by a given address or its subscription.
     */
    function isOperatorFiltered(address registrant, address operator) external view returns (bool) {
        address registration = _registrations[registrant];
        if (registration != registrant) {
            return _filteredOperators[registration].contains(operator);
        }
        return _filteredOperators[registrant].contains(operator);
    }

    /**
     * @notice Returns true if a codeHash is filtered by a given address or its subscription.
     */
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external view returns (bool) {
        address registration = _registrations[registrant];
        if (registration != registrant) {
            return _filteredCodeHashes[registration].contains(codeHash);
        }
        return _filteredCodeHashes[registrant].contains(codeHash);
    }

    /**
     * @notice Returns true if the hash of an address's code is filtered by a given address or its subscription.
     */
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external view returns (bool) {
        bytes32 codeHash = operatorWithCode.codehash;
        address registration = _registrations[registrant];
        if (registration != registrant) {
            return _filteredCodeHashes[registration].contains(codeHash);
        }
        return _filteredCodeHashes[registrant].contains(codeHash);
    }

    /**
     * @notice Returns true if an address has registered
     */
    function isRegistered(address registrant) external view returns (bool) {
        return _registrations[registrant] != address(0);
    }

    /**
     * @notice Returns a list of filtered operators for a given address or its subscription.
     */
    function filteredOperators(address registrant) external view returns (address[] memory) {
        address registration = _registrations[registrant];
        if (registration != registrant) {
            return _filteredOperators[registration].values();
        }
        return _filteredOperators[registrant].values();
    }

    /**
     * @notice Returns the set of filtered codeHashes for a given address or its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredCodeHashes(address registrant) external view returns (bytes32[] memory) {
        address registration = _registrations[registrant];
        if (registration != registrant) {
            return _filteredCodeHashes[registration].values();
        }
        return _filteredCodeHashes[registrant].values();
    }

    /**
     * @notice Returns the filtered operator at the given index of the set of filtered operators for a given address or
     *         its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredOperatorAt(address registrant, uint256 index) external view returns (address) {
        address registration = _registrations[registrant];
        if (registration != registrant) {
            return _filteredOperators[registration].at(index);
        }
        return _filteredOperators[registrant].at(index);
    }

    /**
     * @notice Returns the filtered codeHash at the given index of the list of filtered codeHashes for a given address or
     *         its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredCodeHashAt(address registrant, uint256 index) external view returns (bytes32) {
        address registration = _registrations[registrant];
        if (registration != registrant) {
            return _filteredCodeHashes[registration].at(index);
        }
        return _filteredCodeHashes[registrant].at(index);
    }

    /// @dev Convenience method to compute the code hash of an arbitrary contract
    function codeHashOf(address a) external view returns (bytes32) {
        return a.codehash;
    }
}


pragma solidity ^0.8.13;


abstract contract OperatorFilterer {
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY =
        IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);

    constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
        // will not revert, but the contract will need to be registered with the registry once it is deployed in
        // order for the modifier to filter addresses.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (subscribe) {
                OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
                } else {
                    OPERATOR_FILTER_REGISTRY.register(address(this));
                }
            }
        }
    }

    modifier onlyAllowedOperator(address from) virtual {
        // Allow spending tokens from addresses with balance
        // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
        // from an EOA.
        if (from != msg.sender) {
            _checkFilterOperator(msg.sender);
        }
        _;
    }

    modifier onlyAllowedOperatorApproval(address operator) virtual {
        _checkFilterOperator(operator);
        _;
    }

    function _checkFilterOperator(address operator) internal view virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
                revert OperatorNotAllowed(operator);
            }
        }
    }
}


// File: contracts/DefaultOperatorFilterer.sol


pragma solidity ^0.8.13;


/**
 * @title  DefaultOperatorFilterer
 * @notice Inherits from OperatorFilterer and automatically subscribes to the default OpenSea subscription.
 */
abstract contract DefaultOperatorFilterer is OperatorFilterer {
    address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);

    constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}
// 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/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)



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


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.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);
}



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: @openzeppelin/contracts/utils/Context.sol

pragma solidity ^0.8.0;



interface IERC721Enumerable is IERC721 {
  
    function totalSupply() external view returns (uint256);


    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);


    function tokenByIndex(uint256 index) external view returns (uint256);
}

pragma solidity ^0.8.0;

abstract contract ReentrancyGuard {

    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }


    modifier nonReentrant() {
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        _status = _ENTERED;

        _;

        _status = _NOT_ENTERED;
    }
}


// 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/token/ERC721/ERC721.sol


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

pragma solidity ^0.8.0;




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


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

pragma solidity ^0.8.0;


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, IERC721Enumerable, DefaultOperatorFilterer {
    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();
        }
    }

    function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
        require(index < balanceOf(owner), "ERC721A: owner index out of bounds");
        uint256 numMintedSoFar = totalSupply();
        uint256 tokenIdsIdx;
        address currOwnershipAddr;

        unchecked {
            for (uint256 i; i < numMintedSoFar; i++) {
                TokenOwnership memory ownership = _ownerships[i];
                if (ownership.addr != address(0)) {
                    currOwnershipAddr = ownership.addr;
                }
                if (currOwnershipAddr == owner) {
                    if (tokenIdsIdx == index) {
                        return i;
                    }
                    tokenIdsIdx++;
                }
            }
        }

        revert("ERC721A: unable to get token of owner by index");
    }

    function tokenByIndex(uint256 index) public view override returns (uint256) {
        require(index < totalSupply(), "ERC721A: global index out of bounds");
        return index;
    }

    /**
     * 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 ||
            interfaceId == type(IERC721Enumerable).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 ? string(abi.encodePacked(baseURI, tokenId.toString())) : '';
    }

    /**
     * @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 virtual override onlyAllowedOperator(to) {
        address owner = ERC721A.ownerOf(tokenId);
        require(to != owner, "ERC721A: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721A: approve caller is not owner nor approved for all"
        );

        _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 onlyAllowedOperator(operator) {
        require(operator != _msgSender(), "ERC721A: approve to caller");

        _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 onlyAllowedOperator(from){
        _transfer(from, to, tokenId);
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override onlyAllowedOperator(from){
        _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 {}
}


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

abstract contract Ownable2Step is Ownable {
    address private _pendingOwner;

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

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

    /**
     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual override onlyOwner {
        _pendingOwner = newOwner;
        emit OwnershipTransferStarted(owner(), newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual override {
        delete _pendingOwner;
        super._transferOwnership(newOwner);
    }

    /**
     * @dev The new owner accepts the ownership transfer.
     */
    function acceptOwnership() external {
        address sender = _msgSender();
        require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner");
        _transferOwnership(sender);
    }
}

contract OwnedRegistrant is Ownable2Step {
    address constant registry = 0x000000000000AAeB6D7670E522A718067333cd4E;

    constructor(address _owner) {
        IOperatorFilterRegistry(registry).register(address(this));
        transferOwnership(_owner);
    }
}


pragma solidity ^0.8.13;

/**
 * @title  UpdatableOperatorFilterer
 * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
 *         registrant's entries in the OperatorFilterRegistry. This contract allows the Owner to update the
 *         OperatorFilterRegistry address via updateOperatorFilterRegistryAddress, including to the zero address,
 *         which will bypass registry checks.
 *         Note that OpenSea will still disable creator fee enforcement if filtered operators begin fulfilling orders
 *         on-chain, eg, if the registry is revoked or bypassed.
 * @dev    This smart contract is meant to be inherited by token contracts so they can use the following:
 *         - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
 *         - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
 */
abstract contract UpdatableOperatorFilterer {
    error OperatorNotAllowed(address operator);
    error OnlyOwner();

    IOperatorFilterRegistry public operatorFilterRegistry;

    constructor(address _registry, address subscriptionOrRegistrantToCopy, bool subscribe) {
        IOperatorFilterRegistry registry = IOperatorFilterRegistry(_registry);
        operatorFilterRegistry = registry;
        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
        // will not revert, but the contract will need to be registered with the registry once it is deployed in
        // order for the modifier to filter addresses.
        if (address(registry).code.length > 0) {
            if (subscribe) {
                registry.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    registry.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
                } else {
                    registry.register(address(this));
                }
            }
        }
    }

    modifier onlyAllowedOperator(address from) virtual {
        // Allow spending tokens from addresses with balance
        // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
        // from an EOA.
        if (from != msg.sender) {
            _checkFilterOperator(msg.sender);
        }
        _;
    }

    modifier onlyAllowedOperatorApproval(address operator) virtual {
        _checkFilterOperator(operator);
        _;
    }

    /**
     * @notice Update the address that the contract will make OperatorFilter checks against. When set to the zero
     *         address, checks will be bypassed. OnlyOwner.
     */
    function updateOperatorFilterRegistryAddress(address newRegistry) public virtual {
        if (msg.sender != owner()) {
            revert OnlyOwner();
        }
        operatorFilterRegistry = IOperatorFilterRegistry(newRegistry);
    }

    /**
     * @dev assume the contract has an owner, but leave specific Ownable implementation up to inheriting contract
     */
    function owner() public view virtual returns (address);

    function _checkFilterOperator(address operator) internal view virtual {
        IOperatorFilterRegistry registry = operatorFilterRegistry;
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(registry) != address(0) && address(registry).code.length > 0) {
            if (!registry.isOperatorAllowed(address(this), operator)) {
                revert OperatorNotAllowed(operator);
            }
        }
    }
}


pragma solidity ^0.8.13;

/**
 * @title  RevokableOperatorFilterer
 * @notice This contract is meant to allow contracts to permanently skip OperatorFilterRegistry checks if desired. The
 *         Registry itself has an "unregister" function, but if the contract is ownable, the owner can re-register at
 *         any point. As implemented, this abstract contract allows the contract owner to permanently skip the
 *         OperatorFilterRegistry checks by calling revokeOperatorFilterRegistry. Once done, the registry
 *         address cannot be further updated.
 *         Note that OpenSea will still disable creator fee enforcement if filtered operators begin fulfilling orders
 *         on-chain, eg, if the registry is revoked or bypassed.
 */
abstract contract RevokableOperatorFilterer is UpdatableOperatorFilterer {
    error RegistryHasBeenRevoked();
    error InitialRegistryAddressCannotBeZeroAddress();

    bool public isOperatorFilterRegistryRevoked;

    constructor(address _registry, address subscriptionOrRegistrantToCopy, bool subscribe)
        UpdatableOperatorFilterer(_registry, subscriptionOrRegistrantToCopy, subscribe)
    {
        // don't allow creating a contract with a permanently revoked registry
        if (_registry == address(0)) {
            revert InitialRegistryAddressCannotBeZeroAddress();
        }
    }

    function _checkFilterOperator(address operator) internal view virtual override {
        if (address(operatorFilterRegistry) != address(0)) {
            super._checkFilterOperator(operator);
        }
    }

    /**
     * @notice Update the address that the contract will make OperatorFilter checks against. When set to the zero
     *         address, checks will be permanently bypassed, and the address cannot be updated again. OnlyOwner.
     */
    function updateOperatorFilterRegistryAddress(address newRegistry) public override {
        if (msg.sender != owner()) {
            revert OnlyOwner();
        }
        // if registry has been revoked, do not allow further updates
        if (isOperatorFilterRegistryRevoked) {
            revert RegistryHasBeenRevoked();
        }

        operatorFilterRegistry = IOperatorFilterRegistry(newRegistry);
    }

    /**
     * @notice Revoke the OperatorFilterRegistry address, permanently bypassing checks. OnlyOwner.
     */
    function revokeOperatorFilterRegistry() public {
        if (msg.sender != owner()) {
            revert OnlyOwner();
        }
        // if registry has been revoked, do not allow further updates
        if (isOperatorFilterRegistryRevoked) {
            revert RegistryHasBeenRevoked();
        }

        // set to zero address to bypass checks
        operatorFilterRegistry = IOperatorFilterRegistry(address(0));
        isOperatorFilterRegistryRevoked = true;
    }
}

pragma solidity ^0.8.13;

/**
 * @title  RevokableDefaultOperatorFilterer
 * @notice Inherits from RevokableOperatorFilterer and automatically subscribes to the default OpenSea subscription.
 *         Note that OpenSea will disable creator fee enforcement if filtered operators begin fulfilling orders
 *         on-chain, eg, if the registry is revoked or bypassed.
 */
abstract contract RevokableDefaultOperatorFilterer is RevokableOperatorFilterer {
    address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);

    constructor() RevokableOperatorFilterer(0x000000000000AAeB6D7670E522A718067333cd4E, DEFAULT_SUBSCRIPTION, true) {}
}


pragma solidity ^0.8.9;

contract BitcoinApePunks is ERC721A, Ownable, ReentrancyGuard {
    using Strings for uint256;
    
    uint   public price             = 0.0069 ether;
    uint   public maxTx          = 20;
    uint   public maxSupply          = 10000;
    uint256 public reservedSupply = 100;
    string private baseURI;
    bool   public mintEnabled;  
    uint   public maxPerFree        = 1;
    uint   public totalFreeMinted = 0;
    uint   public totalFree         = 10000;
    uint256 public bridgeFee;
    bool public inscriptionPhaseActive = false;
    
    mapping(address => uint256) public _FreeMinted;

    constructor() ERC721A("Bitcoin Ape Punks", "BAP") {}

    function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
        require(_exists(_tokenId),"ERC721Metadata: URI query for nonexistent token");
        string memory currentBaseURI = _baseURI();
        return bytes(currentBaseURI).length > 0
            ? string(abi.encodePacked(currentBaseURI,Strings.toString(_tokenId),".json"))
            : "";
    }

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

    function mint(uint256 count) external payable {
        
        bool MintForFree = ((totalFreeMinted < totalFree) &&
            (_FreeMinted[msg.sender] < maxPerFree));

        if (MintForFree) { 
            require(mintEnabled, "Mint is not live yet");
            require(totalSupply() + count <= maxSupply, "No more");
            require(count <= maxTx, "Max per TX reached.");
            if(count >= (maxPerFree - _FreeMinted[msg.sender]))
            {
             require(msg.value >= (count * price) - ((maxPerFree - _FreeMinted[msg.sender]) * price), "Please send the exact ETH amount");
             _FreeMinted[msg.sender] = maxPerFree;
             totalFreeMinted += maxPerFree;
            }
            else if(count < (maxPerFree - _FreeMinted[msg.sender]))
            {
             require(msg.value >= 0, "Please send the exact ETH amount");
             _FreeMinted[msg.sender] += count;
             totalFreeMinted += count;
            }
        }
        else{
            require(mintEnabled, "Mint is not live yet");
            require(msg.value >= count * price, "Please send the exact ETH amount");
            require(totalSupply() + count <= maxSupply, "No more");
            require(count <= maxTx, "Max per TX reached.");
        }

        _safeMint(msg.sender, count);
    }

    function reservedMint(uint256 Amount) external onlyOwner
    {
        uint256 Remaining = reservedSupply;

        require(totalSupply() + Amount <= maxSupply, "No more supply to be minted");
        require(Remaining >= Amount, "Reserved Supply Minted");
    
        reservedSupply = Remaining - Amount;
        _safeMint(msg.sender, Amount);
       // totalSupply() += Amount;
    }

    function toggleMinting() external onlyOwner {
      mintEnabled = !mintEnabled;
    }

    function setBridgeFee(uint256 _fee) public onlyOwner {
        bridgeFee = _fee;
    }
    
    function toggleInscriptionsActive() public onlyOwner {
        inscriptionPhaseActive = !inscriptionPhaseActive;
    }
    
    function bridge(uint256 _tokenId) public payable {
        
        require(ownerOf(_tokenId) == msg.sender, "You do not own this token.");
        require(msg.value >= bridgeFee, "Insufficient fee to inscribe this token to ordinal BTC.");

        _burn(_tokenId);     
    }

    function bridgeMultiple(uint256[] calldata tokenIds) public payable {
    
     require(msg.value >= (tokenIds.length * bridgeFee), "Insufficient fee to inscribe this token to ordinal BTC.");

     for (uint i = 0; i < tokenIds.length; i++) {
      require(ownerOf(tokenIds[i]) == msg.sender, "You do not own this token.");
        _burn(tokenIds[i]);
       }
    }

    function burnUnbridgedTokens(uint256[] calldata tokenIds) public onlyOwner {
    for (uint i = 0; i < tokenIds.length; i++) {
      require(_exists(tokenIds[i]), "Token does not exist");
      _burn(tokenIds[i]);
      }
    }
   
   function setBaseUri(string memory baseuri_) public onlyOwner {
        baseURI = baseuri_;
    }

    function setCost(uint256 price_) external onlyOwner {
        price = price_;
    }

    function costInspect() public view returns (uint256) {
        return price;
    }

     function setmaxTx(uint256 _MaxTx) external onlyOwner {
        maxTx = _MaxTx;
    }

    function setMaxTotalFree(uint256 MaxTotalFree_) external onlyOwner {
        totalFree = MaxTotalFree_;
    }

    function setMaxPerFree(uint256 MaxPerFree_) external onlyOwner {
        maxPerFree = MaxPerFree_;
    }

    function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
        super.setApprovalForAll(operator, approved);
    }

    function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
        super.approve(operator, tokenId);
    }

    function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
        super.transferFrom(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
        super.safeTransferFrom(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
        public
        override
        onlyAllowedOperator(from)
    {
        super.safeTransferFrom(from, to, tokenId, data);
    }

    function withdraw() external onlyOwner nonReentrant {
        (bool success, ) = msg.sender.call{value: address(this).balance}("");
        require(success, "Transfer failed.");
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","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"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_FreeMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","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":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"bridge","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"bridgeFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"bridgeMultiple","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"burnUnbridgedTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"costInspect","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"inscriptionPhaseActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"maxPerFree","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"uint256","name":"Amount","type":"uint256"}],"name":"reservedMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reservedSupply","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":"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":"baseuri_","type":"string"}],"name":"setBaseUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_fee","type":"uint256"}],"name":"setBridgeFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"price_","type":"uint256"}],"name":"setCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"MaxPerFree_","type":"uint256"}],"name":"setMaxPerFree","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"MaxTotalFree_","type":"uint256"}],"name":"setMaxTotalFree","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_MaxTx","type":"uint256"}],"name":"setmaxTx","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toggleInscriptionsActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"totalFree","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFreeMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

113347:5942:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83744:372;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;86926:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;88503:204;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;118349:157;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;81904:303;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;113858:42;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;118514:163;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;82215:886;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;113781:39;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;119100:186;;;;;;;;;;;;;:::i;:::-;;116501:120;;;;;;;;;;;;;:::i;:::-;;40348:143;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;118685:171;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;117652:85;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;113594:35;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;83109:187;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;117932:111;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;86734:125;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;84182:206;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;103473:103;;;;;;;;;;;;;:::i;:::-;;113507:33;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;113913:46;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;116306:87;;;;;;;;;;;;;:::i;:::-;;113827:24;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;115902:396;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;102825:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;116633:282;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;117305:231;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;87095:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;116401:88;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;113454:46;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;114547:1347;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;117546:98;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;118165:176;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;117838:86;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;118864:228;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;117745:84;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;113699:35;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;114028:395;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;113665:25;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;113547:40;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;113741:33;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;118051:106;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;89176:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;116923:374;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;103731:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;83744:372;83846:4;83898:25;83883:40;;;:11;:40;;;;:105;;;;83955:33;83940:48;;;:11;:48;;;;83883:105;:172;;;;84020:35;84005:50;;;:11;:50;;;;83883:172;:225;;;;84072:36;84096:11;84072:23;:36::i;:::-;83883:225;83863:245;;83744:372;;;:::o;86926:100::-;86980:13;87013:5;87006:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;86926:100;:::o;88503:204::-;88571:7;88596:16;88604:7;88596;:16::i;:::-;88591:64;;88621:34;;;;;;;;;;;;;;88591:64;88675:15;:24;88691:7;88675:24;;;;;;;;;;;;;;;;;;;;;88668:31;;88503:204;;;:::o;118349:157::-;118445:8;41869:30;41890:8;41869:20;:30::i;:::-;118466:32:::1;118480:8;118490:7;118466:13;:32::i;:::-;118349:157:::0;;;:::o;81904:303::-;81948:7;82173:15;:13;:15::i;:::-;82158:12;;82142:13;;:28;:46;82135:53;;81904:303;:::o;113858:42::-;;;;;;;;;;;;;:::o;118514:163::-;118615:4;41697:10;41689:18;;:4;:18;;;41685:83;;41724:32;41745:10;41724:20;:32::i;:::-;41685:83;118632:37:::1;118651:4;118657:2;118661:7;118632:18;:37::i;:::-;118514:163:::0;;;;:::o;82215:886::-;82304:7;82340:16;82350:5;82340:9;:16::i;:::-;82332:5;:24;82324:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;82406:22;82431:13;:11;:13::i;:::-;82406:38;;82455:19;82485:25;82553:9;82548:466;82568:14;82564:1;:18;82548:466;;;82608:31;82642:11;:14;82654:1;82642:14;;;;;;;;;;;82608:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;82705:1;82679:28;;:9;:14;;;:28;;;82675:111;;82752:9;:14;;;82732:34;;82675:111;82829:5;82808:26;;:17;:26;;;82804:195;;82878:5;82863:11;:20;82859:85;;82919:1;82912:8;;;;;;;;;82859:85;82966:13;;;;;;;82804:195;82589:425;82584:3;;;;;;;82548:466;;;;83037:56;;;;;;;;;;:::i;:::-;;;;;;;;82215:886;;;;;:::o;113781:39::-;;;;:::o;119100:186::-;102711:13;:11;:13::i;:::-;76983:1:::1;77133:7;;:19:::0;77125:63:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;76983:1;77201:7;:18;;;;119164:12:::2;119182:10;:15;;119205:21;119182:49;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;119163:68;;;119250:7;119242:36;;;;;;;;;;;;:::i;:::-;;;;;;;;;119152:134;76939:1:::1;77246:7;:22;;;;119100:186::o:0;116501:120::-;102711:13;:11;:13::i;:::-;116591:22:::1;;;;;;;;;;;116590:23;116565:22;;:48;;;;;;;;;;;;;;;;;;116501:120::o:0;40348:143::-;40448:42;40348:143;:::o;118685:171::-;118790:4;41697:10;41689:18;;:4;:18;;;41685:83;;41724:32;41745:10;41724:20;:32::i;:::-;41685:83;118807:41:::1;118830:4;118836:2;118840:7;118807:22;:41::i;:::-;118685:171:::0;;;;:::o;117652:85::-;102711:13;:11;:13::i;:::-;117723:6:::1;117715:5;:14;;;;117652:85:::0;:::o;113594:35::-;;;;:::o;83109:187::-;83176:7;83212:13;:11;:13::i;:::-;83204:5;:21;83196:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;83283:5;83276:12;;83109:187;;;:::o;117932:111::-;102711:13;:11;:13::i;:::-;118022::::1;118010:9;:25;;;;117932:111:::0;:::o;86734:125::-;86798:7;86825:21;86838:7;86825:12;:21::i;:::-;:26;;;86818:33;;86734:125;;;:::o;84182:206::-;84246:7;84287:1;84270:19;;:5;:19;;;84266:60;;84298:28;;;;;;;;;;;;;;84266:60;84352:12;:19;84365:5;84352:19;;;;;;;;;;;;;;;:27;;;;;;;;;;;;84344:36;;84337:43;;84182:206;;;:::o;103473:103::-;102711:13;:11;:13::i;:::-;103538:30:::1;103565:1;103538:18;:30::i;:::-;103473:103::o:0;113507:33::-;;;;:::o;113913:46::-;;;;;;;;;;;;;;;;;:::o;116306:87::-;102711:13;:11;:13::i;:::-;116374:11:::1;;;;;;;;;;;116373:12;116359:11;;:26;;;;;;;;;;;;;;;;;;116306:87::o:0;113827:24::-;;;;:::o;115902:396::-;102711:13;:11;:13::i;:::-;115975:17:::1;115995:14;;115975:34;;116056:9;;116046:6;116030:13;:11;:13::i;:::-;:22;;;;:::i;:::-;:35;;116022:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;116129:6;116116:9;:19;;116108:54;;;;;;;;;;;;:::i;:::-;;;;;;;;;116208:6;116196:9;:18;;;;:::i;:::-;116179:14;:35;;;;116225:29;116235:10;116247:6;116225:9;:29::i;:::-;115964:334;115902:396:::0;:::o;102825:87::-;102871:7;102898:6;;;;;;;;;;;102891:13;;102825:87;:::o;116633:282::-;116732:10;116711:31;;:17;116719:8;116711:7;:17::i;:::-;:31;;;116703:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;116805:9;;116792;:22;;116784:90;;;;;;;;;;;;:::i;:::-;;;;;;;;;116887:15;116893:8;116887:5;:15::i;:::-;116633:282;:::o;117305:231::-;102711:13;:11;:13::i;:::-;117392:6:::1;117387:142;117408:8;;:15;;117404:1;:19;117387:142;;;117447:20;117455:8;;117464:1;117455:11;;;;;;;:::i;:::-;;;;;;;;117447:7;:20::i;:::-;117439:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;117501:18;117507:8;;117516:1;117507:11;;;;;;;:::i;:::-;;;;;;;;117501:5;:18::i;:::-;117425:3;;;;;:::i;:::-;;;;117387:142;;;;117305:231:::0;;:::o;87095:104::-;87151:13;87184:7;87177:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;87095:104;:::o;116401:88::-;102711:13;:11;:13::i;:::-;116477:4:::1;116465:9;:16;;;;116401:88:::0;:::o;113454:46::-;;;;:::o;114547:1347::-;114614:16;114653:9;;114635:15;;:27;114634:84;;;;;114707:10;;114681:11;:23;114693:10;114681:23;;;;;;;;;;;;;;;;:36;114634:84;114614:105;;114736:11;114732:1114;;;114773:11;;;;;;;;;;;114765:44;;;;;;;;;;;;:::i;:::-;;;;;;;;;114857:9;;114848:5;114832:13;:11;:13::i;:::-;:21;;;;:::i;:::-;:34;;114824:54;;;;;;;;;;;;:::i;:::-;;;;;;;;;114910:5;;114901;:14;;114893:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;114980:11;:23;114992:10;114980:23;;;;;;;;;;;;;;;;114967:10;;:36;;;;:::i;:::-;114957:5;:47;114954:580;;115116:5;;115089:11;:23;115101:10;115089:23;;;;;;;;;;;;;;;;115076:10;;:36;;;;:::i;:::-;115075:46;;;;:::i;:::-;115065:5;;115057;:13;;;;:::i;:::-;115056:66;;;;:::i;:::-;115043:9;:79;;115035:124;;;;;;;;;;;;:::i;:::-;;;;;;;;;115201:10;;115175:11;:23;115187:10;115175:23;;;;;;;;;;;;;;;:36;;;;115246:10;;115227:15;;:29;;;;;;;:::i;:::-;;;;;;;;114954:580;;;115316:11;:23;115328:10;115316:23;;;;;;;;;;;;;;;;115303:10;;:36;;;;:::i;:::-;115294:5;:46;115291:243;;;115392:1;115379:9;:14;;115371:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;115473:5;115446:11;:23;115458:10;115446:23;;;;;;;;;;;;;;;;:32;;;;;;;:::i;:::-;;;;;;;;115513:5;115494:15;;:24;;;;;;;:::i;:::-;;;;;;;;115291:243;114954:580;114732:1114;;;115582:11;;;;;;;;;;;115574:44;;;;;;;;;;;;:::i;:::-;;;;;;;;;115662:5;;115654;:13;;;;:::i;:::-;115641:9;:26;;115633:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;115752:9;;115743:5;115727:13;:11;:13::i;:::-;:21;;;;:::i;:::-;:34;;115719:54;;;;;;;;;;;;:::i;:::-;;;;;;;;;115805:5;;115796;:14;;115788:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;114732:1114;115858:28;115868:10;115880:5;115858:9;:28::i;:::-;114593:1301;114547:1347;:::o;117546:98::-;102711:13;:11;:13::i;:::-;117628:8:::1;117618:7;:18;;;;;;:::i;:::-;;117546:98:::0;:::o;118165:176::-;118269:8;41869:30;41890:8;41869:20;:30::i;:::-;118290:43:::1;118314:8;118324;118290:23;:43::i;:::-;118165:176:::0;;;:::o;117838:86::-;102711:13;:11;:13::i;:::-;117910:6:::1;117902:5;:14;;;;117838:86:::0;:::o;118864:228::-;119015:4;41697:10;41689:18;;:4;:18;;;41685:83;;41724:32;41745:10;41724:20;:32::i;:::-;41685:83;119037:47:::1;119060:4;119066:2;119070:7;119079:4;119037:22;:47::i;:::-;118864:228:::0;;;;;:::o;117745:84::-;117789:7;117816:5;;117809:12;;117745:84;:::o;113699:35::-;;;;:::o;114028:395::-;114102:13;114136:17;114144:8;114136:7;:17::i;:::-;114128:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;114215:28;114246:10;:8;:10::i;:::-;114215:41;;114305:1;114280:14;114274:28;:32;:141;;;;;;;;;;;;;;;;;114346:14;114361:26;114378:8;114361:16;:26::i;:::-;114329:67;;;;;;;;;:::i;:::-;;;;;;;;;;;;;114274:141;114267:148;;;114028:395;;;:::o;113665:25::-;;;;;;;;;;;;;:::o;113547:40::-;;;;:::o;113741:33::-;;;;:::o;118051:106::-;102711:13;:11;:13::i;:::-;118138:11:::1;118125:10;:24;;;;118051:106:::0;:::o;89176:164::-;89273:4;89297:18;:25;89316:5;89297:25;;;;;;;;;;;;;;;:35;89323:8;89297:35;;;;;;;;;;;;;;;;;;;;;;;;;89290:42;;89176:164;;;;:::o;116923:374::-;117045:9;;117027:8;;:15;;:27;;;;:::i;:::-;117013:9;:42;;117005:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;117130:6;117125:165;117146:8;;:15;;117142:1;:19;117125:165;;;117209:10;117185:34;;:20;117193:8;;117202:1;117193:11;;;;;;;:::i;:::-;;;;;;;;117185:7;:20::i;:::-;:34;;;117177:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;117261:18;117267:8;;117276:1;117267:11;;;;;;;:::i;:::-;;;;;;;;117261:5;:18::i;:::-;117163:3;;;;;:::i;:::-;;;;117125:165;;;;116923:374;;:::o;103731:201::-;102711:13;:11;:13::i;:::-;103840:1:::1;103820:22;;:8;:22;;::::0;103812:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;103896:28;103915:8;103896:18;:28::i;:::-;103731:201:::0;:::o;70370:157::-;70455:4;70494:25;70479:40;;;:11;:40;;;;70472:47;;70370:157;;;:::o;90603:174::-;90660:4;90703:7;90684:15;:13;:15::i;:::-;:26;;:53;;;;;90724:13;;90714:7;:23;90684:53;:85;;;;;90742:11;:20;90754:7;90742:20;;;;;;;;;;;:27;;;;;;;;;;;;90741:28;90684:85;90677:92;;90603:174;;;:::o;41927:419::-;42166:1;40448:42;42118:45;;;:49;42114:225;;;40448:42;42189;;;42240:4;42247:8;42189:67;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;42184:144;;42303:8;42284:28;;;;;;;;;;;:::i;:::-;;;;;;;;42184:144;42114:225;41927:419;:::o;87992:445::-;88082:2;41697:10;41689:18;;:4;:18;;;41685:83;;41724:32;41745:10;41724:20;:32::i;:::-;41685:83;88097:13:::1;88113:24;88129:7;88113:15;:24::i;:::-;88097:40;;88162:5;88156:11;;:2;:11;;::::0;88148:58:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;88257:5;88241:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;88266:37;88283:5;88290:12;:10;:12::i;:::-;88266:16;:37::i;:::-;88241:62;88219:169;;;;;;;;;;;;:::i;:::-;;;;;;;;;88401:28;88410:2;88414:7;88423:5;88401:8;:28::i;:::-;88086:351;87992:445:::0;;;:::o;81678:92::-;81734:7;81678:92;:::o;89406:195::-;89549:4;41697:10;41689:18;;:4;:18;;;41685:83;;41724:32;41745:10;41724:20;:32::i;:::-;41685:83;89565:28:::1;89575:4;89581:2;89585:7;89565:9;:28::i;:::-;89406:195:::0;;;;:::o;102990:132::-;103065:12;:10;:12::i;:::-;103054:23;;:7;:5;:7::i;:::-;:23;;;103046:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;102990:132::o;89672:211::-;89819:4;41697:10;41689:18;;:4;:18;;;41685:83;;41724:32;41745:10;41724:20;:32::i;:::-;41685:83;89836:39:::1;89853:4;89859:2;89863:7;89836:39;;;;;;;;;;;::::0;:16:::1;:39::i;:::-;89672:211:::0;;;;:::o;85563:1109::-;85625:21;;:::i;:::-;85659:12;85674:7;85659:22;;85742:4;85723:15;:13;:15::i;:::-;:23;;:47;;;;;85757:13;;85750:4;:20;85723:47;85719:886;;;85791:31;85825:11;:17;85837:4;85825:17;;;;;;;;;;;85791:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85866:9;:16;;;85861:729;;85937:1;85911:28;;:9;:14;;;:28;;;85907:101;;85975:9;85968:16;;;;;;85907:101;86310:261;86317:4;86310:261;;;86350:6;;;;;;;;86395:11;:17;86407:4;86395:17;;;;;;;;;;;86383:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;86469:1;86443:28;;:9;:14;;;:28;;;86439:109;;86511:9;86504:16;;;;;;86439:109;86310:261;;;85861:729;85772:833;85719:886;86633:31;;;;;;;;;;;;;;85563:1109;;;;:::o;104092:191::-;104166:16;104185:6;;;;;;;;;;;104166:25;;104211:8;104202:6;;:17;;;;;;;;;;;;;;;;;;104266:8;104235:40;;104256:8;104235:40;;;;;;;;;;;;104155:128;104092:191;:::o;90785:104::-;90854:27;90864:2;90868:8;90854:27;;;;;;;;;;;;:9;:27::i;:::-;90785:104;;:::o;95916:89::-;95976:21;95982:7;95991:5;95976;:21::i;:::-;95916:89;:::o;88779:326::-;88883:8;41697:10;41689:18;;:4;:18;;;41685:83;;41724:32;41745:10;41724:20;:32::i;:::-;41685:83;88924:12:::1;:10;:12::i;:::-;88912:24;;:8;:24;;::::0;88904:63:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;89025:8;88980:18;:32;88999:12;:10;:12::i;:::-;88980:32;;;;;;;;;;;;;;;:42;89013:8;88980:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;89078:8;89049:48;;89064:12;:10;:12::i;:::-;89049:48;;;89088:8;89049:48;;;;;;:::i;:::-;;;;;;;;88779:326:::0;;;:::o;89954:394::-;90130:4;41697:10;41689:18;;:4;:18;;;41685:83;;41724:32;41745:10;41724:20;:32::i;:::-;41685:83;90146:28:::1;90156:4;90162:2;90166:7;90146:9;:28::i;:::-;90189:15;:2;:13;;;:15::i;:::-;:76;;;;;90209:56;90240:4;90246:2;90250:7;90259:5;90209:30;:56::i;:::-;90208:57;90189:76;90185:156;;;90289:40;;;;;;;;;;;;;;90185:156;89954:394:::0;;;;;:::o;114431:108::-;114491:13;114524:7;114517:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;114431:108;:::o;56132:716::-;56188:13;56239:14;56276:1;56256:17;56267:5;56256:10;:17::i;:::-;:21;56239:38;;56292:20;56326:6;56315:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56292:41;;56348:11;56477:6;56473:2;56469:15;56461:6;56457:28;56450:35;;56514:288;56521:4;56514:288;;;56546:5;;;;;;;;56688:8;56683:2;56676:5;56672:14;56667:30;56662:3;56654:44;56744:2;56735:11;;;;;;:::i;:::-;;;;;56778:1;56769:5;:10;56514:288;56765:21;56514:288;56823:6;56816:13;;;;;56132:716;;;:::o;77908:98::-;77961:7;77988:10;77981:17;;77908:98;:::o;98760:196::-;98902:2;98875:15;:24;98891:7;98875:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;98940:7;98936:2;98920:28;;98929:5;98920:28;;;;;;;;;;;;98760:196;;;:::o;93703:2130::-;93818:35;93856:21;93869:7;93856:12;:21::i;:::-;93818:59;;93916:4;93894:26;;:13;:18;;;:26;;;93890:67;;93929:28;;;;;;;;;;;;;;93890:67;93970:22;94012:4;93996:20;;:12;:10;:12::i;:::-;:20;;;:73;;;;94033:36;94050:4;94056:12;:10;:12::i;:::-;94033:16;:36::i;:::-;93996:73;:126;;;;94110:12;:10;:12::i;:::-;94086:36;;:20;94098:7;94086:11;:20::i;:::-;:36;;;93996:126;93970:153;;94141:17;94136:66;;94167:35;;;;;;;;;;;;;;94136:66;94231:1;94217:16;;:2;:16;;;94213:52;;94242:23;;;;;;;;;;;;;;94213:52;94278:43;94300:4;94306:2;94310:7;94319:1;94278:21;:43::i;:::-;94386:35;94403:1;94407:7;94416:4;94386:8;:35::i;:::-;94747:1;94717:12;:18;94730:4;94717:18;;;;;;;;;;;;;;;:26;;;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94791:1;94763:12;:16;94776:2;94763:16;;;;;;;;;;;;;;;:24;;;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94809:31;94843:11;:20;94855:7;94843:20;;;;;;;;;;;94809:54;;94894:2;94878:8;:13;;;:18;;;;;;;;;;;;;;;;;;94944:15;94911:8;:23;;;:49;;;;;;;;;;;;;;;;;;95212:19;95244:1;95234:7;:11;95212:33;;95260:31;95294:11;:24;95306:11;95294:24;;;;;;;;;;;95260:58;;95362:1;95337:27;;:8;:13;;;;;;;;;;;;:27;;;95333:384;;95547:13;;95532:11;:28;95528:174;;95601:4;95585:8;:13;;;:20;;;;;;;;;;;;;;;;;;95654:13;:28;;;95628:8;:23;;;:54;;;;;;;;;;;;;;;;;;95528:174;95333:384;94692:1036;;;95764:7;95760:2;95745:27;;95754:4;95745:27;;;;;;;;;;;;95783:42;95804:4;95810:2;95814:7;95823:1;95783:20;:42::i;:::-;93807:2026;;93703:2130;;;:::o;91252:163::-;91375:32;91381:2;91385:8;91395:5;91402:4;91375:5;:32::i;:::-;91252:163;;;:::o;96234:2408::-;96314:35;96352:21;96365:7;96352:12;:21::i;:::-;96314:59;;96386:12;96401:13;:18;;;96386:33;;96436:13;96432:290;;;96466:22;96508:4;96492:20;;:12;:10;:12::i;:::-;:20;;;:77;;;;96533:36;96550:4;96556:12;:10;:12::i;:::-;96533:16;:36::i;:::-;96492:77;:134;;;;96614:12;:10;:12::i;:::-;96590:36;;:20;96602:7;96590:11;:20::i;:::-;:36;;;96492:134;96466:161;;96649:17;96644:66;;96675:35;;;;;;;;;;;;;;96644:66;96451:271;96432:290;96734:51;96756:4;96770:1;96774:7;96783:1;96734:21;:51::i;:::-;96850:35;96867:1;96871:7;96880:4;96850:8;:35::i;:::-;97181:31;97215:12;:18;97228:4;97215:18;;;;;;;;;;;;;;;97181:52;;97271:1;97248:11;:19;;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;97315:1;97287:11;:24;;;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;97415:31;97449:11;:20;97461:7;97449:20;;;;;;;;;;;97415:54;;97500:4;97484:8;:13;;;:20;;;;;;;;;;;;;;;;;;97552:15;97519:8;:23;;;:49;;;;;;;;;;;;;;;;;;97601:4;97583:8;:15;;;:22;;;;;;;;;;;;;;;;;;97853:19;97885:1;97875:7;:11;97853:33;;97901:31;97935:11;:24;97947:11;97935:24;;;;;;;;;;;97901:58;;98003:1;97978:27;;:8;:13;;;;;;;;;;;;:27;;;97974:384;;98188:13;;98173:11;:28;98169:174;;98242:4;98226:8;:13;;;:20;;;;;;;;;;;;;;;;;;98295:13;:28;;;98269:8;:23;;;:54;;;;;;;;;;;;;;;;;;98169:174;97974:384;97156:1213;;;;98413:7;98409:1;98386:35;;98395:4;98386:35;;;;;;;;;;;;98432:50;98453:4;98467:1;98471:7;98480:1;98432:20;:50::i;:::-;98609:12;;:14;;;;;;;;;;;;;96303:2339;;96234:2408;;:::o;59259:326::-;59319:4;59576:1;59554:7;:19;;;:23;59547:30;;59259:326;;;:::o;99448:667::-;99611:4;99648:2;99632:36;;;99669:12;:10;:12::i;:::-;99683:4;99689:7;99698:5;99632:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;99628:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;99883:1;99866:6;:13;:18;99862:235;;99912:40;;;;;;;;;;;;;;99862:235;100055:6;100049:13;100040:6;100036:2;100032:15;100025:38;99628:480;99761:45;;;99751:55;;;:6;:55;;;;99744:62;;;99448:667;;;;;;:::o;52998:922::-;53051:7;53071:14;53088:1;53071:18;;53138:6;53129:5;:15;53125:102;;53174:6;53165:15;;;;;;:::i;:::-;;;;;53209:2;53199:12;;;;53125:102;53254:6;53245:5;:15;53241:102;;53290:6;53281:15;;;;;;:::i;:::-;;;;;53325:2;53315:12;;;;53241:102;53370:6;53361:5;:15;53357:102;;53406:6;53397:15;;;;;;:::i;:::-;;;;;53441:2;53431:12;;;;53357:102;53486:5;53477;:14;53473:99;;53521:5;53512:14;;;;;;:::i;:::-;;;;;53555:1;53545:11;;;;53473:99;53599:5;53590;:14;53586:99;;53634:5;53625:14;;;;;;:::i;:::-;;;;;53668:1;53658:11;;;;53586:99;53712:5;53703;:14;53699:99;;53747:5;53738:14;;;;;;:::i;:::-;;;;;53781:1;53771:11;;;;53699:99;53825:5;53816;:14;53812:66;;53861:1;53851:11;;;;53812:66;53906:6;53899:13;;;52998:922;;;:::o;100763:159::-;;;;;:::o;101581:158::-;;;;;:::o;91674:1775::-;91813:20;91836:13;;91813:36;;91878:1;91864:16;;:2;:16;;;91860:48;;91889:19;;;;;;;;;;;;;;91860:48;91935:1;91923:8;:13;91919:44;;91945:18;;;;;;;;;;;;;;91919:44;91976:61;92006:1;92010:2;92014:12;92028:8;91976:21;:61::i;:::-;92349:8;92314:12;:16;92327:2;92314:16;;;;;;;;;;;;;;;:24;;;:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92413:8;92373:12;:16;92386:2;92373:16;;;;;;;;;;;;;;;:29;;;:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92472:2;92439:11;:25;92451:12;92439:25;;;;;;;;;;;:30;;;:35;;;;;;;;;;;;;;;;;;92539:15;92489:11;:25;92501:12;92489:25;;;;;;;;;;;:40;;;:66;;;;;;;;;;;;;;;;;;92572:20;92595:12;92572:35;;92622:11;92651:8;92636:12;:23;92622:37;;92680:4;:23;;;;;92688:15;:2;:13;;;:15::i;:::-;92680:23;92676:641;;;92724:314;92780:12;92776:2;92755:38;;92772:1;92755:38;;;;;;;;;;;;92821:69;92860:1;92864:2;92868:14;;;;;;92884:5;92821:30;:69::i;:::-;92816:174;;92926:40;;;;;;;;;;;;;;92816:174;93033:3;93017:12;:19;92724:314;;93119:12;93102:13;;:29;93098:43;;93133:8;;;93098:43;92676:641;;;93182:120;93238:14;;;;;;93234:2;93213:40;;93230:1;93213:40;;;;;;;;;;;;93297:3;93281:12;:19;93182:120;;92676:641;93347:12;93331:13;:28;;;;92289:1082;;93381:60;93410:1;93414:2;93418:12;93432:8;93381:20;:60::i;:::-;91802:1647;91674:1775;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:246::-;1879:1;1889:113;1903:6;1900:1;1897:13;1889:113;;;1988:1;1983:3;1979:11;1973:18;1969:1;1964:3;1960:11;1953:39;1925:2;1922:1;1918:10;1913:15;;1889:113;;;2036:1;2027:6;2022:3;2018:16;2011:27;1860:184;1798:246;;;:::o;2050:102::-;2091:6;2142:2;2138:7;2133:2;2126:5;2122:14;2118:28;2108:38;;2050:102;;;:::o;2158:377::-;2246:3;2274:39;2307:5;2274:39;:::i;:::-;2329:71;2393:6;2388:3;2329:71;:::i;:::-;2322:78;;2409:65;2467:6;2462:3;2455:4;2448:5;2444:16;2409:65;:::i;:::-;2499:29;2521:6;2499:29;:::i;:::-;2494:3;2490:39;2483:46;;2250:285;2158:377;;;;:::o;2541:313::-;2654:4;2692:2;2681:9;2677:18;2669:26;;2741:9;2735:4;2731:20;2727:1;2716:9;2712:17;2705:47;2769:78;2842:4;2833:6;2769:78;:::i;:::-;2761:86;;2541:313;;;;:::o;2860:77::-;2897:7;2926:5;2915:16;;2860:77;;;:::o;2943:122::-;3016:24;3034:5;3016:24;:::i;:::-;3009:5;3006:35;2996:63;;3055:1;3052;3045:12;2996:63;2943:122;:::o;3071:139::-;3117:5;3155:6;3142:20;3133:29;;3171:33;3198:5;3171:33;:::i;:::-;3071:139;;;;:::o;3216:329::-;3275:6;3324:2;3312:9;3303:7;3299:23;3295:32;3292:119;;;3330:79;;:::i;:::-;3292:119;3450:1;3475:53;3520:7;3511:6;3500:9;3496:22;3475:53;:::i;:::-;3465:63;;3421:117;3216:329;;;;:::o;3551:126::-;3588:7;3628:42;3621:5;3617:54;3606:65;;3551:126;;;:::o;3683:96::-;3720:7;3749:24;3767:5;3749:24;:::i;:::-;3738:35;;3683:96;;;:::o;3785:118::-;3872:24;3890:5;3872:24;:::i;:::-;3867:3;3860:37;3785:118;;:::o;3909:222::-;4002:4;4040:2;4029:9;4025:18;4017:26;;4053:71;4121:1;4110:9;4106:17;4097:6;4053:71;:::i;:::-;3909:222;;;;:::o;4137:122::-;4210:24;4228:5;4210:24;:::i;:::-;4203:5;4200:35;4190:63;;4249:1;4246;4239:12;4190:63;4137:122;:::o;4265:139::-;4311:5;4349:6;4336:20;4327:29;;4365:33;4392:5;4365:33;:::i;:::-;4265:139;;;;:::o;4410:474::-;4478:6;4486;4535:2;4523:9;4514:7;4510:23;4506:32;4503:119;;;4541:79;;:::i;:::-;4503:119;4661:1;4686:53;4731:7;4722:6;4711:9;4707:22;4686:53;:::i;:::-;4676:63;;4632:117;4788:2;4814:53;4859:7;4850:6;4839:9;4835:22;4814:53;:::i;:::-;4804:63;;4759:118;4410:474;;;;;:::o;4890:118::-;4977:24;4995:5;4977:24;:::i;:::-;4972:3;4965:37;4890:118;;:::o;5014:222::-;5107:4;5145:2;5134:9;5130:18;5122:26;;5158:71;5226:1;5215:9;5211:17;5202:6;5158:71;:::i;:::-;5014:222;;;;:::o;5242:619::-;5319:6;5327;5335;5384:2;5372:9;5363:7;5359:23;5355:32;5352:119;;;5390:79;;:::i;:::-;5352:119;5510:1;5535:53;5580:7;5571:6;5560:9;5556:22;5535:53;:::i;:::-;5525:63;;5481:117;5637:2;5663:53;5708:7;5699:6;5688:9;5684:22;5663:53;:::i;:::-;5653:63;;5608:118;5765:2;5791:53;5836:7;5827:6;5816:9;5812:22;5791:53;:::i;:::-;5781:63;;5736:118;5242:619;;;;;:::o;5867:60::-;5895:3;5916:5;5909:12;;5867:60;;;:::o;5933:142::-;5983:9;6016:53;6034:34;6043:24;6061:5;6043:24;:::i;:::-;6034:34;:::i;:::-;6016:53;:::i;:::-;6003:66;;5933:142;;;:::o;6081:126::-;6131:9;6164:37;6195:5;6164:37;:::i;:::-;6151:50;;6081:126;;;:::o;6213:157::-;6294:9;6327:37;6358:5;6327:37;:::i;:::-;6314:50;;6213:157;;;:::o;6376:193::-;6494:68;6556:5;6494:68;:::i;:::-;6489:3;6482:81;6376:193;;:::o;6575:284::-;6699:4;6737:2;6726:9;6722:18;6714:26;;6750:102;6849:1;6838:9;6834:17;6825:6;6750:102;:::i;:::-;6575:284;;;;:::o;6865:329::-;6924:6;6973:2;6961:9;6952:7;6948:23;6944:32;6941:119;;;6979:79;;:::i;:::-;6941:119;7099:1;7124:53;7169:7;7160:6;7149:9;7145:22;7124:53;:::i;:::-;7114:63;;7070:117;6865:329;;;;:::o;7200:117::-;7309:1;7306;7299:12;7323:117;7432:1;7429;7422:12;7446:117;7555:1;7552;7545:12;7586:568;7659:8;7669:6;7719:3;7712:4;7704:6;7700:17;7696:27;7686:122;;7727:79;;:::i;:::-;7686:122;7840:6;7827:20;7817:30;;7870:18;7862:6;7859:30;7856:117;;;7892:79;;:::i;:::-;7856:117;8006:4;7998:6;7994:17;7982:29;;8060:3;8052:4;8044:6;8040:17;8030:8;8026:32;8023:41;8020:128;;;8067:79;;:::i;:::-;8020:128;7586:568;;;;;:::o;8160:559::-;8246:6;8254;8303:2;8291:9;8282:7;8278:23;8274:32;8271:119;;;8309:79;;:::i;:::-;8271:119;8457:1;8446:9;8442:17;8429:31;8487:18;8479:6;8476:30;8473:117;;;8509:79;;:::i;:::-;8473:117;8622:80;8694:7;8685:6;8674:9;8670:22;8622:80;:::i;:::-;8604:98;;;;8400:312;8160:559;;;;;:::o;8725:117::-;8834:1;8831;8824:12;8848:180;8896:77;8893:1;8886:88;8993:4;8990:1;8983:15;9017:4;9014:1;9007:15;9034:281;9117:27;9139:4;9117:27;:::i;:::-;9109:6;9105:40;9247:6;9235:10;9232:22;9211:18;9199:10;9196:34;9193:62;9190:88;;;9258:18;;:::i;:::-;9190:88;9298:10;9294:2;9287:22;9077:238;9034:281;;:::o;9321:129::-;9355:6;9382:20;;:::i;:::-;9372:30;;9411:33;9439:4;9431:6;9411:33;:::i;:::-;9321:129;;;:::o;9456:308::-;9518:4;9608:18;9600:6;9597:30;9594:56;;;9630:18;;:::i;:::-;9594:56;9668:29;9690:6;9668:29;:::i;:::-;9660:37;;9752:4;9746;9742:15;9734:23;;9456:308;;;:::o;9770:146::-;9867:6;9862:3;9857;9844:30;9908:1;9899:6;9894:3;9890:16;9883:27;9770:146;;;:::o;9922:425::-;10000:5;10025:66;10041:49;10083:6;10041:49;:::i;:::-;10025:66;:::i;:::-;10016:75;;10114:6;10107:5;10100:21;10152:4;10145:5;10141:16;10190:3;10181:6;10176:3;10172:16;10169:25;10166:112;;;10197:79;;:::i;:::-;10166:112;10287:54;10334:6;10329:3;10324;10287:54;:::i;:::-;10006:341;9922:425;;;;;:::o;10367:340::-;10423:5;10472:3;10465:4;10457:6;10453:17;10449:27;10439:122;;10480:79;;:::i;:::-;10439:122;10597:6;10584:20;10622:79;10697:3;10689:6;10682:4;10674:6;10670:17;10622:79;:::i;:::-;10613:88;;10429:278;10367:340;;;;:::o;10713:509::-;10782:6;10831:2;10819:9;10810:7;10806:23;10802:32;10799:119;;;10837:79;;:::i;:::-;10799:119;10985:1;10974:9;10970:17;10957:31;11015:18;11007:6;11004:30;11001:117;;;11037:79;;:::i;:::-;11001:117;11142:63;11197:7;11188:6;11177:9;11173:22;11142:63;:::i;:::-;11132:73;;10928:287;10713:509;;;;:::o;11228:116::-;11298:21;11313:5;11298:21;:::i;:::-;11291:5;11288:32;11278:60;;11334:1;11331;11324:12;11278:60;11228:116;:::o;11350:133::-;11393:5;11431:6;11418:20;11409:29;;11447:30;11471:5;11447:30;:::i;:::-;11350:133;;;;:::o;11489:468::-;11554:6;11562;11611:2;11599:9;11590:7;11586:23;11582:32;11579:119;;;11617:79;;:::i;:::-;11579:119;11737:1;11762:53;11807:7;11798:6;11787:9;11783:22;11762:53;:::i;:::-;11752:63;;11708:117;11864:2;11890:50;11932:7;11923:6;11912:9;11908:22;11890:50;:::i;:::-;11880:60;;11835:115;11489:468;;;;;:::o;11963:307::-;12024:4;12114:18;12106:6;12103:30;12100:56;;;12136:18;;:::i;:::-;12100:56;12174:29;12196:6;12174:29;:::i;:::-;12166:37;;12258:4;12252;12248:15;12240:23;;11963:307;;;:::o;12276:423::-;12353:5;12378:65;12394:48;12435:6;12394:48;:::i;:::-;12378:65;:::i;:::-;12369:74;;12466:6;12459:5;12452:21;12504:4;12497:5;12493:16;12542:3;12533:6;12528:3;12524:16;12521:25;12518:112;;;12549:79;;:::i;:::-;12518:112;12639:54;12686:6;12681:3;12676;12639:54;:::i;:::-;12359:340;12276:423;;;;;:::o;12718:338::-;12773:5;12822:3;12815:4;12807:6;12803:17;12799:27;12789:122;;12830:79;;:::i;:::-;12789:122;12947:6;12934:20;12972:78;13046:3;13038:6;13031:4;13023:6;13019:17;12972:78;:::i;:::-;12963:87;;12779:277;12718:338;;;;:::o;13062:943::-;13157:6;13165;13173;13181;13230:3;13218:9;13209:7;13205:23;13201:33;13198:120;;;13237:79;;:::i;:::-;13198:120;13357:1;13382:53;13427:7;13418:6;13407:9;13403:22;13382:53;:::i;:::-;13372:63;;13328:117;13484:2;13510:53;13555:7;13546:6;13535:9;13531:22;13510:53;:::i;:::-;13500:63;;13455:118;13612:2;13638:53;13683:7;13674:6;13663:9;13659:22;13638:53;:::i;:::-;13628:63;;13583:118;13768:2;13757:9;13753:18;13740:32;13799:18;13791:6;13788:30;13785:117;;;13821:79;;:::i;:::-;13785:117;13926:62;13980:7;13971:6;13960:9;13956:22;13926:62;:::i;:::-;13916:72;;13711:287;13062:943;;;;;;;:::o;14011:474::-;14079:6;14087;14136:2;14124:9;14115:7;14111:23;14107:32;14104:119;;;14142:79;;:::i;:::-;14104:119;14262:1;14287:53;14332:7;14323:6;14312:9;14308:22;14287:53;:::i;:::-;14277:63;;14233:117;14389:2;14415:53;14460:7;14451:6;14440:9;14436:22;14415:53;:::i;:::-;14405:63;;14360:118;14011:474;;;;;:::o;14491:180::-;14539:77;14536:1;14529:88;14636:4;14633:1;14626:15;14660:4;14657:1;14650:15;14677:320;14721:6;14758:1;14752:4;14748:12;14738:22;;14805:1;14799:4;14795:12;14826:18;14816:81;;14882:4;14874:6;14870:17;14860:27;;14816:81;14944:2;14936:6;14933:14;14913:18;14910:38;14907:84;;14963:18;;:::i;:::-;14907:84;14728:269;14677:320;;;:::o;15003:221::-;15143:34;15139:1;15131:6;15127:14;15120:58;15212:4;15207:2;15199:6;15195:15;15188:29;15003:221;:::o;15230:366::-;15372:3;15393:67;15457:2;15452:3;15393:67;:::i;:::-;15386:74;;15469:93;15558:3;15469:93;:::i;:::-;15587:2;15582:3;15578:12;15571:19;;15230:366;;;:::o;15602:419::-;15768:4;15806:2;15795:9;15791:18;15783:26;;15855:9;15849:4;15845:20;15841:1;15830:9;15826:17;15819:47;15883:131;16009:4;15883:131;:::i;:::-;15875:139;;15602:419;;;:::o;16027:233::-;16167:34;16163:1;16155:6;16151:14;16144:58;16236:16;16231:2;16223:6;16219:15;16212:41;16027:233;:::o;16266:366::-;16408:3;16429:67;16493:2;16488:3;16429:67;:::i;:::-;16422:74;;16505:93;16594:3;16505:93;:::i;:::-;16623:2;16618:3;16614:12;16607:19;;16266:366;;;:::o;16638:419::-;16804:4;16842:2;16831:9;16827:18;16819:26;;16891:9;16885:4;16881:20;16877:1;16866:9;16862:17;16855:47;16919:131;17045:4;16919:131;:::i;:::-;16911:139;;16638:419;;;:::o;17063:181::-;17203:33;17199:1;17191:6;17187:14;17180:57;17063:181;:::o;17250:366::-;17392:3;17413:67;17477:2;17472:3;17413:67;:::i;:::-;17406:74;;17489:93;17578:3;17489:93;:::i;:::-;17607:2;17602:3;17598:12;17591:19;;17250:366;;;:::o;17622:419::-;17788:4;17826:2;17815:9;17811:18;17803:26;;17875:9;17869:4;17865:20;17861:1;17850:9;17846:17;17839:47;17903:131;18029:4;17903:131;:::i;:::-;17895:139;;17622:419;;;:::o;18047:147::-;18148:11;18185:3;18170:18;;18047:147;;;;:::o;18200:114::-;;:::o;18320:398::-;18479:3;18500:83;18581:1;18576:3;18500:83;:::i;:::-;18493:90;;18592:93;18681:3;18592:93;:::i;:::-;18710:1;18705:3;18701:11;18694:18;;18320:398;;;:::o;18724:379::-;18908:3;18930:147;19073:3;18930:147;:::i;:::-;18923:154;;19094:3;19087:10;;18724:379;;;:::o;19109:166::-;19249:18;19245:1;19237:6;19233:14;19226:42;19109:166;:::o;19281:366::-;19423:3;19444:67;19508:2;19503:3;19444:67;:::i;:::-;19437:74;;19520:93;19609:3;19520:93;:::i;:::-;19638:2;19633:3;19629:12;19622:19;;19281:366;;;:::o;19653:419::-;19819:4;19857:2;19846:9;19842:18;19834:26;;19906:9;19900:4;19896:20;19892:1;19881:9;19877:17;19870:47;19934:131;20060:4;19934:131;:::i;:::-;19926:139;;19653:419;;;:::o;20078:222::-;20218:34;20214:1;20206:6;20202:14;20195:58;20287:5;20282:2;20274:6;20270:15;20263:30;20078:222;:::o;20306:366::-;20448:3;20469:67;20533:2;20528:3;20469:67;:::i;:::-;20462:74;;20545:93;20634:3;20545:93;:::i;:::-;20663:2;20658:3;20654:12;20647:19;;20306:366;;;:::o;20678:419::-;20844:4;20882:2;20871:9;20867:18;20859:26;;20931:9;20925:4;20921:20;20917:1;20906:9;20902:17;20895:47;20959:131;21085:4;20959:131;:::i;:::-;20951:139;;20678:419;;;:::o;21103:180::-;21151:77;21148:1;21141:88;21248:4;21245:1;21238:15;21272:4;21269:1;21262:15;21289:191;21329:3;21348:20;21366:1;21348:20;:::i;:::-;21343:25;;21382:20;21400:1;21382:20;:::i;:::-;21377:25;;21425:1;21422;21418:9;21411:16;;21446:3;21443:1;21440:10;21437:36;;;21453:18;;:::i;:::-;21437:36;21289:191;;;;:::o;21486:177::-;21626:29;21622:1;21614:6;21610:14;21603:53;21486:177;:::o;21669:366::-;21811:3;21832:67;21896:2;21891:3;21832:67;:::i;:::-;21825:74;;21908:93;21997:3;21908:93;:::i;:::-;22026:2;22021:3;22017:12;22010:19;;21669:366;;;:::o;22041:419::-;22207:4;22245:2;22234:9;22230:18;22222:26;;22294:9;22288:4;22284:20;22280:1;22269:9;22265:17;22258:47;22322:131;22448:4;22322:131;:::i;:::-;22314:139;;22041:419;;;:::o;22466:172::-;22606:24;22602:1;22594:6;22590:14;22583:48;22466:172;:::o;22644:366::-;22786:3;22807:67;22871:2;22866:3;22807:67;:::i;:::-;22800:74;;22883:93;22972:3;22883:93;:::i;:::-;23001:2;22996:3;22992:12;22985:19;;22644:366;;;:::o;23016:419::-;23182:4;23220:2;23209:9;23205:18;23197:26;;23269:9;23263:4;23259:20;23255:1;23244:9;23240:17;23233:47;23297:131;23423:4;23297:131;:::i;:::-;23289:139;;23016:419;;;:::o;23441:194::-;23481:4;23501:20;23519:1;23501:20;:::i;:::-;23496:25;;23535:20;23553:1;23535:20;:::i;:::-;23530:25;;23579:1;23576;23572:9;23564:17;;23603:1;23597:4;23594:11;23591:37;;;23608:18;;:::i;:::-;23591:37;23441:194;;;;:::o;23641:176::-;23781:28;23777:1;23769:6;23765:14;23758:52;23641:176;:::o;23823:366::-;23965:3;23986:67;24050:2;24045:3;23986:67;:::i;:::-;23979:74;;24062:93;24151:3;24062:93;:::i;:::-;24180:2;24175:3;24171:12;24164:19;;23823:366;;;:::o;24195:419::-;24361:4;24399:2;24388:9;24384:18;24376:26;;24448:9;24442:4;24438:20;24434:1;24423:9;24419:17;24412:47;24476:131;24602:4;24476:131;:::i;:::-;24468:139;;24195:419;;;:::o;24620:242::-;24760:34;24756:1;24748:6;24744:14;24737:58;24829:25;24824:2;24816:6;24812:15;24805:50;24620:242;:::o;24868:366::-;25010:3;25031:67;25095:2;25090:3;25031:67;:::i;:::-;25024:74;;25107:93;25196:3;25107:93;:::i;:::-;25225:2;25220:3;25216:12;25209:19;;24868:366;;;:::o;25240:419::-;25406:4;25444:2;25433:9;25429:18;25421:26;;25493:9;25487:4;25483:20;25479:1;25468:9;25464:17;25457:47;25521:131;25647:4;25521:131;:::i;:::-;25513:139;;25240:419;;;:::o;25665:180::-;25713:77;25710:1;25703:88;25810:4;25807:1;25800:15;25834:4;25831:1;25824:15;25851:170;25991:22;25987:1;25979:6;25975:14;25968:46;25851:170;:::o;26027:366::-;26169:3;26190:67;26254:2;26249:3;26190:67;:::i;:::-;26183:74;;26266:93;26355:3;26266:93;:::i;:::-;26384:2;26379:3;26375:12;26368:19;;26027:366;;;:::o;26399:419::-;26565:4;26603:2;26592:9;26588:18;26580:26;;26652:9;26646:4;26642:20;26638:1;26627:9;26623:17;26616:47;26680:131;26806:4;26680:131;:::i;:::-;26672:139;;26399:419;;;:::o;26824:233::-;26863:3;26886:24;26904:5;26886:24;:::i;:::-;26877:33;;26932:66;26925:5;26922:77;26919:103;;27002:18;;:::i;:::-;26919:103;27049:1;27042:5;27038:13;27031:20;;26824:233;;;:::o;27063:170::-;27203:22;27199:1;27191:6;27187:14;27180:46;27063:170;:::o;27239:366::-;27381:3;27402:67;27466:2;27461:3;27402:67;:::i;:::-;27395:74;;27478:93;27567:3;27478:93;:::i;:::-;27596:2;27591:3;27587:12;27580:19;;27239:366;;;:::o;27611:419::-;27777:4;27815:2;27804:9;27800:18;27792:26;;27864:9;27858:4;27854:20;27850:1;27839:9;27835:17;27828:47;27892:131;28018:4;27892:131;:::i;:::-;27884:139;;27611:419;;;:::o;28036:157::-;28176:9;28172:1;28164:6;28160:14;28153:33;28036:157;:::o;28199:365::-;28341:3;28362:66;28426:1;28421:3;28362:66;:::i;:::-;28355:73;;28437:93;28526:3;28437:93;:::i;:::-;28555:2;28550:3;28546:12;28539:19;;28199:365;;;:::o;28570:419::-;28736:4;28774:2;28763:9;28759:18;28751:26;;28823:9;28817:4;28813:20;28809:1;28798:9;28794:17;28787:47;28851:131;28977:4;28851:131;:::i;:::-;28843:139;;28570:419;;;:::o;28995:169::-;29135:21;29131:1;29123:6;29119:14;29112:45;28995:169;:::o;29170:366::-;29312:3;29333:67;29397:2;29392:3;29333:67;:::i;:::-;29326:74;;29409:93;29498:3;29409:93;:::i;:::-;29527:2;29522:3;29518:12;29511:19;;29170:366;;;:::o;29542:419::-;29708:4;29746:2;29735:9;29731:18;29723:26;;29795:9;29789:4;29785:20;29781:1;29770:9;29766:17;29759:47;29823:131;29949:4;29823:131;:::i;:::-;29815:139;;29542:419;;;:::o;29967:410::-;30007:7;30030:20;30048:1;30030:20;:::i;:::-;30025:25;;30064:20;30082:1;30064:20;:::i;:::-;30059:25;;30119:1;30116;30112:9;30141:30;30159:11;30141:30;:::i;:::-;30130:41;;30320:1;30311:7;30307:15;30304:1;30301:22;30281:1;30274:9;30254:83;30231:139;;30350:18;;:::i;:::-;30231:139;30015:362;29967:410;;;;:::o;30383:182::-;30523:34;30519:1;30511:6;30507:14;30500:58;30383:182;:::o;30571:366::-;30713:3;30734:67;30798:2;30793:3;30734:67;:::i;:::-;30727:74;;30810:93;30899:3;30810:93;:::i;:::-;30928:2;30923:3;30919:12;30912:19;;30571:366;;;:::o;30943:419::-;31109:4;31147:2;31136:9;31132:18;31124:26;;31196:9;31190:4;31186:20;31182:1;31171:9;31167:17;31160:47;31224:131;31350:4;31224:131;:::i;:::-;31216:139;;30943:419;;;:::o;31368:141::-;31417:4;31440:3;31432:11;;31463:3;31460:1;31453:14;31497:4;31494:1;31484:18;31476:26;;31368:141;;;:::o;31515:93::-;31552:6;31599:2;31594;31587:5;31583:14;31579:23;31569:33;;31515:93;;;:::o;31614:107::-;31658:8;31708:5;31702:4;31698:16;31677:37;;31614:107;;;;:::o;31727:393::-;31796:6;31846:1;31834:10;31830:18;31869:97;31899:66;31888:9;31869:97;:::i;:::-;31987:39;32017:8;32006:9;31987:39;:::i;:::-;31975:51;;32059:4;32055:9;32048:5;32044:21;32035:30;;32108:4;32098:8;32094:19;32087:5;32084:30;32074:40;;31803:317;;31727:393;;;;;:::o;32126:142::-;32176:9;32209:53;32227:34;32236:24;32254:5;32236:24;:::i;:::-;32227:34;:::i;:::-;32209:53;:::i;:::-;32196:66;;32126:142;;;:::o;32274:75::-;32317:3;32338:5;32331:12;;32274:75;;;:::o;32355:269::-;32465:39;32496:7;32465:39;:::i;:::-;32526:91;32575:41;32599:16;32575:41;:::i;:::-;32567:6;32560:4;32554:11;32526:91;:::i;:::-;32520:4;32513:105;32431:193;32355:269;;;:::o;32630:73::-;32675:3;32630:73;:::o;32709:189::-;32786:32;;:::i;:::-;32827:65;32885:6;32877;32871:4;32827:65;:::i;:::-;32762:136;32709:189;;:::o;32904:186::-;32964:120;32981:3;32974:5;32971:14;32964:120;;;33035:39;33072:1;33065:5;33035:39;:::i;:::-;33008:1;33001:5;32997:13;32988:22;;32964:120;;;32904:186;;:::o;33096:543::-;33197:2;33192:3;33189:11;33186:446;;;33231:38;33263:5;33231:38;:::i;:::-;33315:29;33333:10;33315:29;:::i;:::-;33305:8;33301:44;33498:2;33486:10;33483:18;33480:49;;;33519:8;33504:23;;33480:49;33542:80;33598:22;33616:3;33598:22;:::i;:::-;33588:8;33584:37;33571:11;33542:80;:::i;:::-;33201:431;;33186:446;33096:543;;;:::o;33645:117::-;33699:8;33749:5;33743:4;33739:16;33718:37;;33645:117;;;;:::o;33768:169::-;33812:6;33845:51;33893:1;33889:6;33881:5;33878:1;33874:13;33845:51;:::i;:::-;33841:56;33926:4;33920;33916:15;33906:25;;33819:118;33768:169;;;;:::o;33942:295::-;34018:4;34164:29;34189:3;34183:4;34164:29;:::i;:::-;34156:37;;34226:3;34223:1;34219:11;34213:4;34210:21;34202:29;;33942:295;;;;:::o;34242:1395::-;34359:37;34392:3;34359:37;:::i;:::-;34461:18;34453:6;34450:30;34447:56;;;34483:18;;:::i;:::-;34447:56;34527:38;34559:4;34553:11;34527:38;:::i;:::-;34612:67;34672:6;34664;34658:4;34612:67;:::i;:::-;34706:1;34730:4;34717:17;;34762:2;34754:6;34751:14;34779:1;34774:618;;;;35436:1;35453:6;35450:77;;;35502:9;35497:3;35493:19;35487:26;35478:35;;35450:77;35553:67;35613:6;35606:5;35553:67;:::i;:::-;35547:4;35540:81;35409:222;34744:887;;34774:618;34826:4;34822:9;34814:6;34810:22;34860:37;34892:4;34860:37;:::i;:::-;34919:1;34933:208;34947:7;34944:1;34941:14;34933:208;;;35026:9;35021:3;35017:19;35011:26;35003:6;34996:42;35077:1;35069:6;35065:14;35055:24;;35124:2;35113:9;35109:18;35096:31;;34970:4;34967:1;34963:12;34958:17;;34933:208;;;35169:6;35160:7;35157:19;35154:179;;;35227:9;35222:3;35218:19;35212:26;35270:48;35312:4;35304:6;35300:17;35289:9;35270:48;:::i;:::-;35262:6;35255:64;35177:156;35154:179;35379:1;35375;35367:6;35363:14;35359:22;35353:4;35346:36;34781:611;;;34744:887;;34334:1303;;;34242:1395;;:::o;35643:234::-;35783:34;35779:1;35771:6;35767:14;35760:58;35852:17;35847:2;35839:6;35835:15;35828:42;35643:234;:::o;35883:366::-;36025:3;36046:67;36110:2;36105:3;36046:67;:::i;:::-;36039:74;;36122:93;36211:3;36122:93;:::i;:::-;36240:2;36235:3;36231:12;36224:19;;35883:366;;;:::o;36255:419::-;36421:4;36459:2;36448:9;36444:18;36436:26;;36508:9;36502:4;36498:20;36494:1;36483:9;36479:17;36472:47;36536:131;36662:4;36536:131;:::i;:::-;36528:139;;36255:419;;;:::o;36680:148::-;36782:11;36819:3;36804:18;;36680:148;;;;:::o;36834:390::-;36940:3;36968:39;37001:5;36968:39;:::i;:::-;37023:89;37105:6;37100:3;37023:89;:::i;:::-;37016:96;;37121:65;37179:6;37174:3;37167:4;37160:5;37156:16;37121:65;:::i;:::-;37211:6;37206:3;37202:16;37195:23;;36944:280;36834:390;;;;:::o;37230:155::-;37370:7;37366:1;37358:6;37354:14;37347:31;37230:155;:::o;37391:400::-;37551:3;37572:84;37654:1;37649:3;37572:84;:::i;:::-;37565:91;;37665:93;37754:3;37665:93;:::i;:::-;37783:1;37778:3;37774:11;37767:18;;37391:400;;;:::o;37797:701::-;38078:3;38100:95;38191:3;38182:6;38100:95;:::i;:::-;38093:102;;38212:95;38303:3;38294:6;38212:95;:::i;:::-;38205:102;;38324:148;38468:3;38324:148;:::i;:::-;38317:155;;38489:3;38482:10;;37797:701;;;;;:::o;38504:225::-;38644:34;38640:1;38632:6;38628:14;38621:58;38713:8;38708:2;38700:6;38696:15;38689:33;38504:225;:::o;38735:366::-;38877:3;38898:67;38962:2;38957:3;38898:67;:::i;:::-;38891:74;;38974:93;39063:3;38974:93;:::i;:::-;39092:2;39087:3;39083:12;39076:19;;38735:366;;;:::o;39107:419::-;39273:4;39311:2;39300:9;39296:18;39288:26;;39360:9;39354:4;39350:20;39346:1;39335:9;39331:17;39324:47;39388:131;39514:4;39388:131;:::i;:::-;39380:139;;39107:419;;;:::o;39532:332::-;39653:4;39691:2;39680:9;39676:18;39668:26;;39704:71;39772:1;39761:9;39757:17;39748:6;39704:71;:::i;:::-;39785:72;39853:2;39842:9;39838:18;39829:6;39785:72;:::i;:::-;39532:332;;;;;:::o;39870:137::-;39924:5;39955:6;39949:13;39940:22;;39971:30;39995:5;39971:30;:::i;:::-;39870:137;;;;:::o;40013:345::-;40080:6;40129:2;40117:9;40108:7;40104:23;40100:32;40097:119;;;40135:79;;:::i;:::-;40097:119;40255:1;40280:61;40333:7;40324:6;40313:9;40309:22;40280:61;:::i;:::-;40270:71;;40226:125;40013:345;;;;:::o;40364:221::-;40504:34;40500:1;40492:6;40488:14;40481:58;40573:4;40568:2;40560:6;40556:15;40549:29;40364:221;:::o;40591:366::-;40733:3;40754:67;40818:2;40813:3;40754:67;:::i;:::-;40747:74;;40830:93;40919:3;40830:93;:::i;:::-;40948:2;40943:3;40939:12;40932:19;;40591:366;;;:::o;40963:419::-;41129:4;41167:2;41156:9;41152:18;41144:26;;41216:9;41210:4;41206:20;41202:1;41191:9;41187:17;41180:47;41244:131;41370:4;41244:131;:::i;:::-;41236:139;;40963:419;;;:::o;41388:244::-;41528:34;41524:1;41516:6;41512:14;41505:58;41597:27;41592:2;41584:6;41580:15;41573:52;41388:244;:::o;41638:366::-;41780:3;41801:67;41865:2;41860:3;41801:67;:::i;:::-;41794:74;;41877:93;41966:3;41877:93;:::i;:::-;41995:2;41990:3;41986:12;41979:19;;41638:366;;;:::o;42010:419::-;42176:4;42214:2;42203:9;42199:18;42191:26;;42263:9;42257:4;42253:20;42249:1;42238:9;42234:17;42227:47;42291:131;42417:4;42291:131;:::i;:::-;42283:139;;42010:419;;;:::o;42435:182::-;42575:34;42571:1;42563:6;42559:14;42552:58;42435:182;:::o;42623:366::-;42765:3;42786:67;42850:2;42845:3;42786:67;:::i;:::-;42779:74;;42862:93;42951:3;42862:93;:::i;:::-;42980:2;42975:3;42971:12;42964:19;;42623:366;;;:::o;42995:419::-;43161:4;43199:2;43188:9;43184:18;43176:26;;43248:9;43242:4;43238:20;43234:1;43223:9;43219:17;43212:47;43276:131;43402:4;43276:131;:::i;:::-;43268:139;;42995:419;;;:::o;43420:176::-;43560:28;43556:1;43548:6;43544:14;43537:52;43420:176;:::o;43602:366::-;43744:3;43765:67;43829:2;43824:3;43765:67;:::i;:::-;43758:74;;43841:93;43930:3;43841:93;:::i;:::-;43959:2;43954:3;43950:12;43943:19;;43602:366;;;:::o;43974:419::-;44140:4;44178:2;44167:9;44163:18;44155:26;;44227:9;44221:4;44217:20;44213:1;44202:9;44198:17;44191:47;44255:131;44381:4;44255:131;:::i;:::-;44247:139;;43974:419;;;:::o;44399:180::-;44447:77;44444:1;44437:88;44544:4;44541:1;44534:15;44568:4;44565:1;44558:15;44585:98;44636:6;44670:5;44664:12;44654:22;;44585:98;;;:::o;44689:168::-;44772:11;44806:6;44801:3;44794:19;44846:4;44841:3;44837:14;44822:29;;44689:168;;;;:::o;44863:373::-;44949:3;44977:38;45009:5;44977:38;:::i;:::-;45031:70;45094:6;45089:3;45031:70;:::i;:::-;45024:77;;45110:65;45168:6;45163:3;45156:4;45149:5;45145:16;45110:65;:::i;:::-;45200:29;45222:6;45200:29;:::i;:::-;45195:3;45191:39;45184:46;;44953:283;44863:373;;;;:::o;45242:640::-;45437:4;45475:3;45464:9;45460:19;45452:27;;45489:71;45557:1;45546:9;45542:17;45533:6;45489:71;:::i;:::-;45570:72;45638:2;45627:9;45623:18;45614:6;45570:72;:::i;:::-;45652;45720:2;45709:9;45705:18;45696:6;45652:72;:::i;:::-;45771:9;45765:4;45761:20;45756:2;45745:9;45741:18;45734:48;45799:76;45870:4;45861:6;45799:76;:::i;:::-;45791:84;;45242:640;;;;;;;:::o;45888:141::-;45944:5;45975:6;45969:13;45960:22;;45991:32;46017:5;45991:32;:::i;:::-;45888:141;;;;:::o;46035:349::-;46104:6;46153:2;46141:9;46132:7;46128:23;46124:32;46121:119;;;46159:79;;:::i;:::-;46121:119;46279:1;46304:63;46359:7;46350:6;46339:9;46335:22;46304:63;:::i;:::-;46294:73;;46250:127;46035:349;;;;:::o

Swarm Source

ipfs://88a2040ffbac4cbf7c04cb5e67b8f5bed4d7e46ac6874c233249ab0473778906

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services