Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

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

import { DataTypes } from "src/libraries/DataTypes.sol";
import { Errors } from "src/libraries/Errors.sol";
import { ValidationLogic } from "src/libraries/ValidationLogic.sol";

import { ERC721A } from "erc721a/contracts/ERC721A.sol";
import { Ownable } from "solady/src/auth/Ownable.sol";
import { LibMap } from "solady/src/utils/LibMap.sol";
import { LibBitmap } from "solady/src/utils/LibBitmap.sol";
import { EnumerableSetLib } from "solady/src/utils/EnumerableSetLib.sol";

contract Snorfliks is ERC721A, Ownable {
    using LibMap for LibMap.Uint16Map;
    using LibBitmap for LibBitmap.Bitmap;
    using EnumerableSetLib for EnumerableSetLib.Uint8Set;

    event Upgrade(address indexed caller, uint256 indexed tokenId, uint256 rank, uint256 amount);
    event Donate(uint256 indexed senderId, uint256 indexed targetId, uint256 rank, uint256 amount);
    event Allocate(uint256 indexed senderId, uint256 indexed targetId, uint256 rank, uint256 amount);
    event Claim(uint256 indexed senderId, uint256 indexed targetId, uint256 rank, uint256 amount);
    event Purge(uint256 start, uint256 end, uint256 cooldownExpiry);
    event Purged(uint256 indexed senderId, uint256 indexed targetId);
    event AirdroppedChunk(uint8 indexed chunkNum);

    uint256 public immutable LOCK_TIME;
    bytes32 public immutable PROVENANCE_HASH;

    uint256 public constant MAX_SUPPLY = 2500;
    uint256 public constant MAX_PER_ADDRESS_MINT = 30;
    uint256 public constant MAX_BATCH_SIZE = 10;
    uint256 public constant MINT_COST = 90 ether;
    uint256 public constant UPGRADE_COST = 40 ether;
    uint256 public constant DURATION = 3 days;
    uint256 public constant COOLDOWN = 10 days;

    LibBitmap.Bitmap internal _purged;
    LibBitmap.Bitmap internal _cooldown;
    LibBitmap.Bitmap internal _safe;
    LibMap.Uint16Map internal _receive;
    mapping(uint256 id => LibMap.Uint16Map nonceRanks) internal _ranksToAssignById;
    EnumerableSetLib.Uint8Set private _processedChunksForAirdrop;

    uint32 public start;
    uint32 public end;
    uint32 public cooldownExpiry;
    address public WITHDRAW_ADDRESS;
    string public PEACE_URI;
    string public PURGE_URI;
    uint8 public currentNonce;

    constructor(
        uint256 _lockTime,
        bytes32 _provenanceHash,
        uint32 _cooldownExpiry
    )
        ERC721A("Purge of the Snorfliks", "PURGE")
    {
        _initializeOwner(msg.sender);
        LOCK_TIME = _lockTime;
        PROVENANCE_HASH = _provenanceHash;
        cooldownExpiry = _cooldownExpiry;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                      MINT OPERATIONS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    function mint(uint8 amount) external payable {
        uint256 totalCost = amount * MINT_COST;
        uint64 numMintedForAddr_ = _getAux(msg.sender);

        ValidationLogic.validateMint(
            DataTypes.ValidateMintParams({
                amount: amount,
                isLocked: block.timestamp >= LOCK_TIME,
                numMintedForAddr: numMintedForAddr_,
                hasFunds: msg.value >= totalCost,
                totalMinted: _totalMinted(),
                maxSupply: MAX_SUPPLY,
                maxPerAddr: MAX_PER_ADDRESS_MINT
            })
        );

        _setAux(msg.sender, numMintedForAddr_ + amount);
        _mintWrapper(msg.sender, amount);

        if (msg.value > totalCost) {
            (bool sent,) = msg.sender.call{ value: msg.value - totalCost }("");
            if (!sent) revert Errors.TransferFailed();
        }
    }

    function _mintWrapper(address to, uint256 amount) private {
        uint256 batches = amount / MAX_BATCH_SIZE;

        for (uint256 i; i < batches; ++i) {
            _mint(to, MAX_BATCH_SIZE);
        }

        if (amount % MAX_BATCH_SIZE > 0) {
            _mint(to, amount % MAX_BATCH_SIZE);
        }
    }

    function airdrop(address[] calldata receivers, uint256[] calldata amounts, uint8 chunkNum) external onlyOwner {
        if (_processedChunksForAirdrop.contains(chunkNum)) {
            revert Errors.Snorfliks_ChunkAlreadyProcessed();
        }
        _processedChunksForAirdrop.add(chunkNum);
        privilegedMint(receivers, amounts);
        emit AirdroppedChunk(chunkNum);
    }

    function privilegedMint(address[] calldata receivers, uint256[] calldata amounts) public onlyOwner {
        if (start != 0) revert Errors.Snorfliks_CannotAirdrop();

        if (receivers.length != amounts.length || receivers.length == 0) {
            revert Errors.Snorfliks_MismatchedArrays();
        }
        for (uint256 i; i < receivers.length; ++i) {
            _mintWrapper(receivers[i], amounts[i]);
        }
        if (_totalMinted() > MAX_SUPPLY) {
            revert Errors.Snorfliks_OverMaxSupply();
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                      TOKEN OPERATIONS                      */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    function upgrade(uint256 index, uint256 amount) external payable {
        uint256 totalCost = amount * UPGRADE_COST;

        ValidationLogic.validateUpgrade(
            DataTypes.ValidateUpgradeParams({
                isValidIndex: _exists(index) && !_purged.get(index),
                hasFunds: msg.value >= totalCost,
                isPurgeOn: getPhase() == Phase.PURGE
            })
        );

        _receive.set(index, _receive.get(index) + uint16(amount));
        emit Upgrade(msg.sender, index, _upgrade(index, uint16(amount)), amount);

        if (msg.value > totalCost) {
            (bool sent,) = msg.sender.call{ value: msg.value - totalCost }("");
            if (!sent) revert Errors.TransferFailed();
        }
    }

    function _upgrade(uint256 index, uint16 amount) internal returns (uint256) {
        if (_ownershipIsInitialized(index)) {
            uint16 newRank = uint16(_ownershipAt(index).extraData) + amount;
            _setExtraDataAt(index, newRank);
            return newRank;
        } else {
            _initializeOwnershipAt(index);
            _setExtraDataAt(index, amount);
            return amount;
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                      RANK OPERATIONS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    function donate(uint256 senderId, uint256 targetId) external {
        ValidationLogic.validateRankOps(
            DataTypes.ValidateRankParams({
                isUniqueIndex: senderId != targetId,
                isValidTarget: _exists(targetId) && !_purged.get(targetId),
                isValidSender: isAuthorizedForToken(msg.sender, senderId),
                isPurgeOn: getPhase() == Phase.PURGE,
                isValidNonce: true
            })
        );

        uint16 sourceLimit = uint16(_ownershipAt(senderId).extraData);
        uint16 sinkLimit = _receive.get(targetId);
        uint16 amount = _getRankAmount(sourceLimit, sinkLimit);

        if (amount == 0) revert Errors.Zero();

        _setExtraDataAt(senderId, 0);
        _receive.set(targetId, sinkLimit - amount);
        emit Donate(senderId, targetId, _upgrade(targetId, amount), amount);
    }

    function allocate(uint256 senderId, uint256 targetId) external {
        ValidationLogic.validateRankOps(
            DataTypes.ValidateRankParams({
                isUniqueIndex: senderId != targetId,
                isValidTarget: _exists(targetId) && !_purged.get(targetId),
                isValidSender: isAuthorizedForToken(msg.sender, senderId),
                isPurgeOn: getPhase() == Phase.PURGE,
                isValidNonce: true
            })
        );

        uint8 nonce = currentNonce;
        uint16 sourceLimit = _ranksToAssignById[senderId].get(nonce);
        uint16 sinkLimit = _receive.get(targetId);
        uint16 amount = _getRankAmount(sourceLimit, sinkLimit);

        if (amount == 0) revert Errors.Zero();

        _ranksToAssignById[senderId].set(nonce, 0);
        _receive.set(targetId, sinkLimit - amount);
        emit Allocate(senderId, targetId, _upgrade(targetId, amount), amount);
    }

    function claim(uint256 senderId, uint256 targetId, uint256 nonce) external {
        ValidationLogic.validateRankOps(
            DataTypes.ValidateRankParams({
                isUniqueIndex: senderId != targetId,
                isValidTarget: _exists(targetId) && !_purged.get(targetId),
                isValidSender: isAuthorizedForToken(msg.sender, senderId),
                isPurgeOn: getPhase() == Phase.PURGE,
                isValidNonce: nonce < currentNonce
            })
        );

        uint16 sourceLimit = _ranksToAssignById[targetId].get(nonce);
        uint16 sinkLimit = _receive.get(senderId);
        uint16 amount = _getRankAmount(sourceLimit, sinkLimit);

        if (amount == 0) revert Errors.Zero();

        _ranksToAssignById[targetId].set(nonce, sourceLimit - amount);
        _receive.set(senderId, sinkLimit - amount);
        emit Claim(senderId, targetId, _upgrade(senderId, amount), amount);
    }

    function _getRankAmount(uint16 transferLimit, uint16 receiveLimit) internal pure returns (uint16) {
        return transferLimit <= receiveLimit ? transferLimit : receiveLimit;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                      PURGE OPERATIONS                      */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    function startPurge() external {
        if (block.timestamp >= LOCK_TIME) revert Errors.Snorfliks_Locked();
        if (block.timestamp < cooldownExpiry) revert Errors.Snorfliks_CooldownPeriod();

        _cooldown.unsetBatch(0, MAX_SUPPLY);
        _safe.unsetBatch(0, MAX_SUPPLY);

        uint256 start_ = block.timestamp + 1 days;
        uint256 end_ = start_ + DURATION;
        uint256 cooldownExpiry_ = start_ + COOLDOWN;

        start = uint32(start_);
        end = uint32(end_);
        cooldownExpiry = uint32(cooldownExpiry_);
        unchecked {
            ++currentNonce;
        }

        emit Purge(uint32(start_), uint32(end_), uint32(cooldownExpiry_));
    }

    function purge(uint256 senderId, uint256 targetId) external payable {
        uint256 senderRank = _ownershipAt(senderId).extraData;
        uint256 targetRank = _ownershipAt(targetId).extraData;
        uint256 totalCost = _getPurgeCost(senderRank, targetRank);

        ValidationLogic.validatePurge(
            DataTypes.ValidatePurgeParams({
                isUniqueIndex: senderId != targetId,
                isValidTarget: _exists(targetId) && !_purged.get(targetId),
                isValidSender: isAuthorizedForToken(msg.sender, senderId),
                hasFunds: msg.value >= totalCost,
                isLocked: block.timestamp >= LOCK_TIME,
                isPurgeOn: getPhase() == Phase.PURGE,
                senderOnCooldown: _cooldown.get(senderId),
                targetSafe: _safe.get(targetId)
            })
        );

        _cooldown.set(senderId);
        _purged.set(targetId);
        _ranksToAssignById[senderId].set(currentNonce, uint16(targetRank));
        if (targetRank >= senderRank + 5) _safe.set(senderId);

        if (msg.value > totalCost) {
            (bool sent,) = msg.sender.call{ value: msg.value - totalCost }("");
            if (!sent) revert Errors.TransferFailed();
        }

        emit Purged(senderId, targetId);
    }

    function _getPurgeCost(uint256 attackerRank, uint256 targetRank) internal pure returns (uint256) {
        uint256 PURGE_COSTS = 0x1fa4173e10e50c4e08e8067c04b00366027601c2014f00f000af0082005a003c;

        if (attackerRank >= targetRank) {
            return (PURGE_COSTS & 0xFFFF) * 1e18;
        } else {
            uint256 diff = targetRank - attackerRank;
            return diff >= 15 ? ((PURGE_COSTS >> 240) & 0xFFFF) * 1e18 : ((PURGE_COSTS >> (diff * 16)) & 0xFFFF) * 1e18;
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           WITHDRAW                         */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    function withdraw() external returns (uint256) {
        if (msg.sender != WITHDRAW_ADDRESS) revert Errors.Snorfliks_OnlyWithdrawer();

        uint256 balance = address(this).balance;
        if (balance == 0) revert Errors.Zero();

        (bool sent,) = WITHDRAW_ADDRESS.call{ value: balance }("");
        if (!sent) revert Errors.TransferFailed();
        return balance;
    }

    function setWithdrawAddress(address withdrawAddress) external onlyOwner {
        if (WITHDRAW_ADDRESS != address(0)) revert Errors.AlreadySet();
        WITHDRAW_ADDRESS = withdrawAddress;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           METADATA                         */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    function _baseURI() internal view override returns (string memory) {
        return block.timestamp >= start && block.timestamp < end ? PURGE_URI : PEACE_URI;
    }

    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();
        string memory baseURI = _baseURI();
        return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, _toString(tokenId))) : "";
    }

    function setURI(string calldata peaceURI, string calldata purgeURI) external onlyOwner {
        if (keccak256(abi.encode(PEACE_URI)) != keccak256(abi.encode(PURGE_URI))) revert Errors.Snorfliks_URISet();
        PEACE_URI = peaceURI;
        PURGE_URI = purgeURI;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           VIEW                             */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    enum Phase {
        PEACE,
        IMMINENT,
        PURGE
    }

    function getPhase() public view returns (Phase) {
        uint32 start_ = start;
        uint32 end_ = end;

        if (start_ == 0) return Phase.PEACE;

        if (block.timestamp >= start_ && block.timestamp < end_) {
            return Phase.PURGE;
        }

        if (block.timestamp < start_) {
            return Phase.IMMINENT;
        }

        return Phase.PEACE;
    }

    function getTokenInfo(uint256 tokenId) public view returns (DataTypes.TokenInfo memory) {
        return DataTypes.TokenInfo({
            exists: _exists(tokenId) && !_purged.get(tokenId),
            cooldown: _cooldown.get(tokenId),
            safe: _safe.get(tokenId),
            rank: uint16(_ownershipAt(tokenId).extraData),
            receiveLimit: _receive.get(tokenId),
            ranksToAssign: _ranksToAssignById[tokenId].get(currentNonce)
        });
    }

    function getRanksToAssign(uint256 tokenId, uint256 nonce) external view returns (uint256) {
        return _ranksToAssignById[tokenId].get(nonce);
    }

    function getNumMinted(address user) external view returns (uint256) {
        return _getAux(user);
    }

    function totalMinted() external view returns (uint256) {
        return _totalMinted();
    }

    function getMaxMintable(address user) external view returns (uint256) {
        if (block.timestamp >= LOCK_TIME) return 0;

        uint256 supplyLeft = MAX_SUPPLY - _totalMinted();
        uint256 userSupplyLeft = MAX_PER_ADDRESS_MINT - _getAux(user);

        return supplyLeft < userSupplyLeft ? supplyLeft : userSupplyLeft;
    }

    function getPurgeCost(uint256 attackerId, uint256 targetId) external view returns (uint256) {
        if (!(_exists(attackerId) || _exists(targetId))) {
            revert Errors.Snorfliks_NonexistentToken();
        }
        return _getPurgeCost(_ownershipAt(attackerId).extraData, _ownershipAt(targetId).extraData);
    }

    function isAuthorizedForToken(address addr, uint256 tokenId) public view returns (bool) {
        return (addr == ownerOf(tokenId)) && (!_purged.get(tokenId));
    }

    function getEligibleTokensCount() external view returns (uint256) {
        return _totalMinted() - _purged.popCount(0, MAX_SUPPLY);
    }
}

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

library DataTypes {
    struct TokenInfo {
        bool exists;
        bool cooldown;
        bool safe;
        uint16 rank;
        uint16 receiveLimit;
        uint16 ranksToAssign;
    }

    struct ValidateMintParams {
        uint8 amount;
        bool isLocked;
        uint64 numMintedForAddr;
        bool hasFunds;
        uint256 totalMinted;
        uint256 maxSupply;
        uint256 maxPerAddr;
    }

    struct ValidateUpgradeParams {
        bool isValidIndex;
        bool hasFunds;
        bool isPurgeOn;
    }

    struct ValidateRankParams {
        bool isUniqueIndex;
        bool isValidTarget;
        bool isValidSender;
        bool isPurgeOn;
        bool isValidNonce;
    }

    struct ValidatePurgeParams {
        bool isUniqueIndex;
        bool isValidTarget;
        bool isValidSender;
        bool hasFunds;
        bool isLocked;
        bool isPurgeOn;
        bool senderOnCooldown;
        bool targetSafe;
    }
}

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

library Errors {
    error TransferFailed();
    error AlreadySet();
    error Zero();

    error Snorfliks_MismatchedArrays();
    error Snorfliks_CannotAirdrop();
    error Snorfliks_ChunkAlreadyProcessed();
    error Snorfliks_Locked();
    error Snorfliks_InsufficientFunds();
    error Snorfliks_NonexistentToken();
    error Snorfliks_InvalidNonce();
    error Snorfliks_OnlyWithdrawer();
    error Snorfliks_OverMaxSupply();
    error Snorfliks_MaxMintedForAddress();
    error Snorfliks_PurgeOn();
    error Snorfliks_PurgeNotOn();
    error Snorfliks_CooldownPeriod();
    error Snorfliks_IdenticalIds();
    error Snorfliks_OnCooldown();
    error Snorfliks_TargetSafe();
    error Snorfliks_URISet();
    error Snorfliks_InvalidIndex();
    error Snorfliks_InvalidTarget();
    error Snorfliks_InvalidSender();

    error Splitter_NotAuthorized();
    error Splitter_NotFinalized();
    error Splitter_ClaimableAmountNotSet();
    error Splitter_AlreadyClaimed();
    error Splitter_Expired();
}

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

import { DataTypes } from "src/libraries/DataTypes.sol";
import { Errors } from "src/libraries/Errors.sol";

library ValidationLogic {
    function validateMint(DataTypes.ValidateMintParams memory data) internal pure {
        if (!data.hasFunds) revert Errors.Snorfliks_InsufficientFunds();

        if (data.isLocked) revert Errors.Snorfliks_Locked();

        if (data.totalMinted + data.amount > data.maxSupply) revert Errors.Snorfliks_OverMaxSupply();

        if (data.numMintedForAddr + data.amount > data.maxPerAddr) revert Errors.Snorfliks_MaxMintedForAddress();
    }

    function validateUpgrade(DataTypes.ValidateUpgradeParams memory data) internal pure {
        if (!data.isValidIndex) revert Errors.Snorfliks_InvalidIndex();

        if (!data.hasFunds) revert Errors.Snorfliks_InsufficientFunds();

        if (data.isPurgeOn) revert Errors.Snorfliks_PurgeOn();
    }

    function validatePurge(DataTypes.ValidatePurgeParams memory data) internal pure {
        if (!data.isUniqueIndex) revert Errors.Snorfliks_IdenticalIds();

        if (!data.isValidTarget) revert Errors.Snorfliks_InvalidTarget();

        if (!data.isValidSender) revert Errors.Snorfliks_InvalidSender();

        if (!data.hasFunds) revert Errors.Snorfliks_InsufficientFunds();

        if (data.isLocked) revert Errors.Snorfliks_Locked();

        if (!data.isPurgeOn) revert Errors.Snorfliks_PurgeNotOn();

        if (data.senderOnCooldown) revert Errors.Snorfliks_OnCooldown();

        if (data.targetSafe) revert Errors.Snorfliks_TargetSafe();
    }

    function validateRankOps(DataTypes.ValidateRankParams memory data) internal pure {
        if (!data.isUniqueIndex) revert Errors.Snorfliks_IdenticalIds();

        if (!data.isValidTarget) revert Errors.Snorfliks_InvalidTarget();

        if (!data.isValidSender) revert Errors.Snorfliks_InvalidSender();

        if (data.isPurgeOn) revert Errors.Snorfliks_PurgeOn();

        if (!data.isValidNonce) revert Errors.Snorfliks_InvalidNonce();
    }
}

// SPDX-License-Identifier: MIT
// ERC721A Contracts v4.3.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;

import "./IERC721A.sol";

/**
 * @dev Interface of ERC721 token receiver.
 */
interface ERC721A__IERC721Receiver {
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    )
        external
        returns (bytes4);
}

/**
 * @title ERC721A
 *
 * @dev Implementation of the [ERC721](https://eips.ethereum.org/EIPS/eip-721)
 * Non-Fungible Token Standard, including the Metadata extension.
 * Optimized for lower gas during batch mints.
 *
 * Token IDs are minted in sequential order (e.g. 0, 1, 2, 3, ...)
 * starting from `_startTokenId()`.
 *
 * The `_sequentialUpTo()` function can be overriden to enable spot mints
 * (i.e. non-consecutive mints) for `tokenId`s greater than `_sequentialUpTo()`.
 *
 * Assumptions:
 *
 * - An owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 * - The maximum token ID cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is IERC721A {
    // Bypass for a `--via-ir` bug (https://github.com/chiru-labs/ERC721A/pull/364).
    struct TokenApprovalRef {
        address value;
    }

    // =============================================================
    //                           CONSTANTS
    // =============================================================

    // Mask of an entry in packed address data.
    uint256 private constant _BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;

    // The bit position of `numberMinted` in packed address data.
    uint256 private constant _BITPOS_NUMBER_MINTED = 64;

    // The bit position of `numberBurned` in packed address data.
    uint256 private constant _BITPOS_NUMBER_BURNED = 128;

    // The bit position of `aux` in packed address data.
    uint256 private constant _BITPOS_AUX = 192;

    // Mask of all 256 bits in packed address data except the 64 bits for `aux`.
    uint256 private constant _BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;

    // The bit position of `startTimestamp` in packed ownership.
    uint256 private constant _BITPOS_START_TIMESTAMP = 160;

    // The bit mask of the `burned` bit in packed ownership.
    uint256 private constant _BITMASK_BURNED = 1 << 224;

    // The bit position of the `nextInitialized` bit in packed ownership.
    uint256 private constant _BITPOS_NEXT_INITIALIZED = 225;

    // The bit mask of the `nextInitialized` bit in packed ownership.
    uint256 private constant _BITMASK_NEXT_INITIALIZED = 1 << 225;

    // The bit position of `extraData` in packed ownership.
    uint256 private constant _BITPOS_EXTRA_DATA = 232;

    // Mask of all 256 bits in a packed ownership except the 24 bits for `extraData`.
    uint256 private constant _BITMASK_EXTRA_DATA_COMPLEMENT = (1 << 232) - 1;

    // The mask of the lower 160 bits for addresses.
    uint256 private constant _BITMASK_ADDRESS = (1 << 160) - 1;

    // The maximum `quantity` that can be minted with {_mintERC2309}.
    // This limit is to prevent overflows on the address data entries.
    // For a limit of 5000, a total of 3.689e15 calls to {_mintERC2309}
    // is required to cause an overflow, which is unrealistic.
    uint256 private constant _MAX_MINT_ERC2309_QUANTITY_LIMIT = 5000;

    // The `Transfer` event signature is given by:
    // `keccak256(bytes("Transfer(address,address,uint256)"))`.
    bytes32 private constant _TRANSFER_EVENT_SIGNATURE =
        0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;

    // =============================================================
    //                            STORAGE
    // =============================================================

    // The next token ID to be minted.
    uint256 private _currentIndex;

    // The number of tokens burned.
    uint256 private _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 {_packedOwnershipOf} implementation for details.
    //
    // Bits Layout:
    // - [0..159]   `addr`
    // - [160..223] `startTimestamp`
    // - [224]      `burned`
    // - [225]      `nextInitialized`
    // - [232..255] `extraData`
    mapping(uint256 => uint256) private _packedOwnerships;

    // Mapping owner address to address data.
    //
    // Bits Layout:
    // - [0..63]    `balance`
    // - [64..127]  `numberMinted`
    // - [128..191] `numberBurned`
    // - [192..255] `aux`
    mapping(address => uint256) private _packedAddressData;

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

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

    // The amount of tokens minted above `_sequentialUpTo()`.
    // We call these spot mints (i.e. non-sequential mints).
    uint256 private _spotMinted;

    // =============================================================
    //                          CONSTRUCTOR
    // =============================================================

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

        if (_sequentialUpTo() < _startTokenId()) _revert(SequentialUpToTooSmall.selector);
    }

    // =============================================================
    //                   TOKEN COUNTING OPERATIONS
    // =============================================================

    /**
     * @dev Returns the starting token ID for sequential mints.
     *
     * Override this function to change the starting token ID for sequential mints.
     *
     * Note: The value returned must never change after any tokens have been minted.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 0;
    }

    /**
     * @dev Returns the maximum token ID (inclusive) for sequential mints.
     *
     * Override this function to return a value less than 2**256 - 1,
     * but greater than `_startTokenId()`, to enable spot (non-sequential) mints.
     *
     * Note: The value returned must never change after any tokens have been minted.
     */
    function _sequentialUpTo() internal view virtual returns (uint256) {
        return type(uint256).max;
    }

    /**
     * @dev Returns the next token ID to be minted.
     */
    function _nextTokenId() internal view virtual returns (uint256) {
        return _currentIndex;
    }

    /**
     * @dev Returns the total number of tokens in existence.
     * Burned tokens will reduce the count.
     * To get the total number of tokens minted, please see {_totalMinted}.
     */
    function totalSupply() public view virtual override returns (uint256 result) {
        // Counter underflow is impossible as `_burnCounter` cannot be incremented
        // more than `_currentIndex + _spotMinted - _startTokenId()` times.
        unchecked {
            // With spot minting, the intermediate `result` can be temporarily negative,
            // and the computation must be unchecked.
            result = _currentIndex - _burnCounter - _startTokenId();
            if (_sequentialUpTo() != type(uint256).max) result += _spotMinted;
        }
    }

    /**
     * @dev Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view virtual returns (uint256 result) {
        // Counter underflow is impossible as `_currentIndex` does not decrement,
        // and it is initialized to `_startTokenId()`.
        unchecked {
            result = _currentIndex - _startTokenId();
            if (_sequentialUpTo() != type(uint256).max) result += _spotMinted;
        }
    }

    /**
     * @dev Returns the total number of tokens burned.
     */
    function _totalBurned() internal view virtual returns (uint256) {
        return _burnCounter;
    }

    /**
     * @dev Returns the total number of tokens that are spot-minted.
     */
    function _totalSpotMinted() internal view virtual returns (uint256) {
        return _spotMinted;
    }

    // =============================================================
    //                    ADDRESS DATA OPERATIONS
    // =============================================================

    /**
     * @dev Returns the number of tokens in `owner`'s account.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        if (owner == address(0)) _revert(BalanceQueryForZeroAddress.selector);
        return _packedAddressData[owner] & _BITMASK_ADDRESS_DATA_ENTRY;
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return (_packedAddressData[owner] >> _BITPOS_NUMBER_MINTED) & _BITMASK_ADDRESS_DATA_ENTRY;
    }

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

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

    /**
     * Sets the auxiliary 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 virtual {
        uint256 packed = _packedAddressData[owner];
        uint256 auxCasted;
        // Cast `aux` with assembly to avoid redundant masking.
        assembly {
            auxCasted := aux
        }
        packed = (packed & _BITMASK_AUX_COMPLEMENT) | (auxCasted << _BITPOS_AUX);
        _packedAddressData[owner] = packed;
    }

    // =============================================================
    //                            IERC165
    // =============================================================

    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30000 gas.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        // The interface IDs are constants representing the first 4 bytes
        // of the XOR of all function selectors in the interface.
        // See: [ERC165](https://eips.ethereum.org/EIPS/eip-165)
        // (e.g. `bytes4(i.functionA.selector ^ i.functionB.selector ^ ...)`)
        return interfaceId == 0x01ffc9a7 // ERC165 interface ID for ERC165.
            || interfaceId == 0x80ac58cd // ERC165 interface ID for ERC721.
            || interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.
    }

    // =============================================================
    //                        IERC721Metadata
    // =============================================================

    /**
     * @dev Returns the token collection name.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        if (!_exists(tokenId)) _revert(URIQueryForNonexistentToken.selector);

        string memory baseURI = _baseURI();
        return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, _toString(tokenId))) : "";
    }

    /**
     * @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, it can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    // =============================================================
    //                     OWNERSHIPS OPERATIONS
    // =============================================================

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        return address(uint160(_packedOwnershipOf(tokenId)));
    }

    /**
     * @dev Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around over time.
     */
    function _ownershipOf(uint256 tokenId) internal view virtual returns (TokenOwnership memory) {
        return _unpackedOwnership(_packedOwnershipOf(tokenId));
    }

    /**
     * @dev Returns the unpacked `TokenOwnership` struct at `index`.
     */
    function _ownershipAt(uint256 index) internal view virtual returns (TokenOwnership memory) {
        return _unpackedOwnership(_packedOwnerships[index]);
    }

    /**
     * @dev Returns whether the ownership slot at `index` is initialized.
     * An uninitialized slot does not necessarily mean that the slot has no owner.
     */
    function _ownershipIsInitialized(uint256 index) internal view virtual returns (bool) {
        return _packedOwnerships[index] != 0;
    }

    /**
     * @dev Initializes the ownership slot minted at `index` for efficiency purposes.
     */
    function _initializeOwnershipAt(uint256 index) internal virtual {
        if (_packedOwnerships[index] == 0) {
            _packedOwnerships[index] = _packedOwnershipOf(index);
        }
    }

    /**
     * @dev Returns the packed ownership data of `tokenId`.
     */
    function _packedOwnershipOf(uint256 tokenId) private view returns (uint256 packed) {
        if (_startTokenId() <= tokenId) {
            packed = _packedOwnerships[tokenId];

            if (tokenId > _sequentialUpTo()) {
                if (_packedOwnershipExists(packed)) return packed;
                _revert(OwnerQueryForNonexistentToken.selector);
            }

            // If the data at the starting slot does not exist, start the scan.
            if (packed == 0) {
                if (tokenId >= _currentIndex) _revert(OwnerQueryForNonexistentToken.selector);
                // Invariant:
                // There will always be an initialized ownership slot
                // (i.e. `ownership.addr != address(0) && ownership.burned == false`)
                // before an unintialized ownership slot
                // (i.e. `ownership.addr == address(0) && ownership.burned == false`)
                // Hence, `tokenId` will not underflow.
                //
                // We can directly compare the packed value.
                // If the address is zero, packed will be zero.
                for (;;) {
                    unchecked {
                        packed = _packedOwnerships[--tokenId];
                    }
                    if (packed == 0) continue;
                    if (packed & _BITMASK_BURNED == 0) return packed;
                    // Otherwise, the token is burned, and we must revert.
                    // This handles the case of batch burned tokens, where only the burned bit
                    // of the starting slot is set, and remaining slots are left uninitialized.
                    _revert(OwnerQueryForNonexistentToken.selector);
                }
            }
            // Otherwise, the data exists and we can skip the scan.
            // This is possible because we have already achieved the target condition.
            // This saves 2143 gas on transfers of initialized tokens.
            // If the token is not burned, return `packed`. Otherwise, revert.
            if (packed & _BITMASK_BURNED == 0) return packed;
        }
        _revert(OwnerQueryForNonexistentToken.selector);
    }

    /**
     * @dev Returns the unpacked `TokenOwnership` struct from `packed`.
     */
    function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
        ownership.addr = address(uint160(packed));
        ownership.startTimestamp = uint64(packed >> _BITPOS_START_TIMESTAMP);
        ownership.burned = packed & _BITMASK_BURNED != 0;
        ownership.extraData = uint24(packed >> _BITPOS_EXTRA_DATA);
    }

    /**
     * @dev Packs ownership data into a single uint256.
     */
    function _packOwnershipData(address owner, uint256 flags) private view returns (uint256 result) {
        assembly {
            // Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.
            owner := and(owner, _BITMASK_ADDRESS)
            // `owner | (block.timestamp << _BITPOS_START_TIMESTAMP) | flags`.
            result := or(owner, or(shl(_BITPOS_START_TIMESTAMP, timestamp()), flags))
        }
    }

    /**
     * @dev Returns the `nextInitialized` flag set if `quantity` equals 1.
     */
    function _nextInitializedFlag(uint256 quantity) private pure returns (uint256 result) {
        // For branchless setting of the `nextInitialized` flag.
        assembly {
            // `(quantity == 1) << _BITPOS_NEXT_INITIALIZED`.
            result := shl(_BITPOS_NEXT_INITIALIZED, eq(quantity, 1))
        }
    }

    // =============================================================
    //                      APPROVAL OPERATIONS
    // =============================================================

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account. See {ERC721A-_approve}.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     */
    function approve(address to, uint256 tokenId) public payable virtual override {
        _approve(to, tokenId, true);
    }

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        if (!_exists(tokenId)) _revert(ApprovalQueryForNonexistentToken.selector);

        return _tokenApprovals[tokenId].value;
    }

    /**
     * @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) public virtual override {
        _operatorApprovals[_msgSenderERC721A()][operator] = approved;
        emit ApprovalForAll(_msgSenderERC721A(), operator, approved);
    }

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

    /**
     * @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. See {_mint}.
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool result) {
        if (_startTokenId() <= tokenId) {
            if (tokenId > _sequentialUpTo()) return _packedOwnershipExists(_packedOwnerships[tokenId]);

            if (tokenId < _currentIndex) {
                uint256 packed;
                while ((packed = _packedOwnerships[tokenId]) == 0) --tokenId;
                result = packed & _BITMASK_BURNED == 0;
            }
        }
    }

    /**
     * @dev Returns whether `packed` represents a token that exists.
     */
    function _packedOwnershipExists(uint256 packed) private pure returns (bool result) {
        assembly {
            // The following is equivalent to `owner != address(0) && burned == false`.
            // Symbolically tested.
            result := gt(and(packed, _BITMASK_ADDRESS), and(packed, _BITMASK_BURNED))
        }
    }

    /**
     * @dev Returns whether `msgSender` is equal to `approvedAddress` or `owner`.
     */
    function _isSenderApprovedOrOwner(
        address approvedAddress,
        address owner,
        address msgSender
    )
        private
        pure
        returns (bool result)
    {
        assembly {
            // Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.
            owner := and(owner, _BITMASK_ADDRESS)
            // Mask `msgSender` to the lower 160 bits, in case the upper bits somehow aren't clean.
            msgSender := and(msgSender, _BITMASK_ADDRESS)
            // `msgSender == owner || msgSender == approvedAddress`.
            result := or(eq(msgSender, owner), eq(msgSender, approvedAddress))
        }
    }

    /**
     * @dev Returns the storage slot and value for the approved address of `tokenId`.
     */
    function _getApprovedSlotAndAddress(uint256 tokenId)
        private
        view
        returns (uint256 approvedAddressSlot, address approvedAddress)
    {
        TokenApprovalRef storage tokenApproval = _tokenApprovals[tokenId];
        // The following is equivalent to `approvedAddress = _tokenApprovals[tokenId].value`.
        assembly {
            approvedAddressSlot := tokenApproval.slot
            approvedAddress := sload(approvedAddressSlot)
        }
    }

    // =============================================================
    //                      TRANSFER OPERATIONS
    // =============================================================

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * 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) public payable virtual override {
        uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

        // Mask `from` to the lower 160 bits, in case the upper bits somehow aren't clean.
        from = address(uint160(uint256(uint160(from)) & _BITMASK_ADDRESS));

        if (address(uint160(prevOwnershipPacked)) != from) _revert(TransferFromIncorrectOwner.selector);

        (uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);

        // The nested ifs save around 20+ gas over a compound boolean condition.
        if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A())) {
            if (!isApprovedForAll(from, _msgSenderERC721A())) _revert(TransferCallerNotOwnerNorApproved.selector);
        }

        _beforeTokenTransfers(from, to, tokenId, 1);

        // Clear approvals from the previous owner.
        assembly {
            if approvedAddress {
                // This is equivalent to `delete _tokenApprovals[tokenId]`.
                sstore(approvedAddressSlot, 0)
            }
        }

        // 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 {
            // We can directly increment and decrement the balances.
            --_packedAddressData[from]; // Updates: `balance -= 1`.
            ++_packedAddressData[to]; // Updates: `balance += 1`.

            // Updates:
            // - `address` to the next owner.
            // - `startTimestamp` to the timestamp of transfering.
            // - `burned` to `false`.
            // - `nextInitialized` to `true`.
            _packedOwnerships[tokenId] =
                _packOwnershipData(to, _BITMASK_NEXT_INITIALIZED | _nextExtraData(from, to, prevOwnershipPacked));

            // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
            if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
                uint256 nextTokenId = tokenId + 1;
                // If the next slot's address is zero and not burned (i.e. packed value is zero).
                if (_packedOwnerships[nextTokenId] == 0) {
                    // If the next slot is within bounds.
                    if (nextTokenId != _currentIndex) {
                        // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                        _packedOwnerships[nextTokenId] = prevOwnershipPacked;
                    }
                }
            }
        }

        // Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
        uint256 toMasked = uint256(uint160(to)) & _BITMASK_ADDRESS;
        assembly {
            // Emit the `Transfer` event.
            log4(
                0, // Start of data (0, since no data).
                0, // End of data (0, since no data).
                _TRANSFER_EVENT_SIGNATURE, // Signature.
                from, // `from`.
                toMasked, // `to`.
                tokenId // `tokenId`.
            )
        }
        if (toMasked == 0) _revert(TransferToZeroAddress.selector);

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

    /**
     * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public payable virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @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 memory _data
    )
        public
        payable
        virtual
        override
    {
        transferFrom(from, to, tokenId);
        if (to.code.length != 0) {
            if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {
                _revert(TransferToNonERC721ReceiverImplementer.selector);
            }
        }
    }

    /**
     * @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 Private function to invoke {IERC721Receiver-onERC721Received} on a target contract.
     *
     * `from` - Previous owner of the given token ID.
     * `to` - Target address that will receive the token.
     * `tokenId` - Token ID to be transferred.
     * `_data` - Optional data to send along with the call.
     *
     * Returns whether the call correctly returned the expected magic value.
     */
    function _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    )
        private
        returns (bool)
    {
        try ERC721A__IERC721Receiver(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data) returns (
            bytes4 retval
        ) {
            return retval == ERC721A__IERC721Receiver(to).onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == 0) {
                _revert(TransferToNonERC721ReceiverImplementer.selector);
            }
            assembly {
                revert(add(32, reason), mload(reason))
            }
        }
    }

    // =============================================================
    //                        MINT OPERATIONS
    // =============================================================

    /**
     * @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 for each mint.
     */
    function _mint(address to, uint256 quantity) internal virtual {
        uint256 startTokenId = _currentIndex;
        if (quantity == 0) _revert(MintZeroQuantity.selector);

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

        // Overflows are incredibly unrealistic.
        // `balance` and `numberMinted` have a maximum limit of 2**64.
        // `tokenId` has a maximum limit of 2**256.
        unchecked {
            // Updates:
            // - `address` to the owner.
            // - `startTimestamp` to the timestamp of minting.
            // - `burned` to `false`.
            // - `nextInitialized` to `quantity == 1`.
            _packedOwnerships[startTokenId] =
                _packOwnershipData(to, _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0));

            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the `balance` and `numberMinted`.
            _packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);

            // Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
            uint256 toMasked = uint256(uint160(to)) & _BITMASK_ADDRESS;

            if (toMasked == 0) _revert(MintToZeroAddress.selector);

            uint256 end = startTokenId + quantity;
            uint256 tokenId = startTokenId;

            if (end - 1 > _sequentialUpTo()) _revert(SequentialMintExceedsLimit.selector);

            do {
                assembly {
                    // Emit the `Transfer` event.
                    log4(
                        0, // Start of data (0, since no data).
                        0, // End of data (0, since no data).
                        _TRANSFER_EVENT_SIGNATURE, // Signature.
                        0, // `address(0)`.
                        toMasked, // `to`.
                        tokenId // `tokenId`.
                    )
                }
                // The `!=` check ensures that large values of `quantity`
                // that overflows uint256 will make the loop run out of gas.
            } while (++tokenId != end);

            _currentIndex = end;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * This function is intended for efficient minting only during contract creation.
     *
     * It emits only one {ConsecutiveTransfer} as defined in
     * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309),
     * instead of a sequence of {Transfer} event(s).
     *
     * Calling this function outside of contract creation WILL make your contract
     * non-compliant with the ERC721 standard.
     * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309
     * {ConsecutiveTransfer} event is only permissible during contract creation.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {ConsecutiveTransfer} event.
     */
    function _mintERC2309(address to, uint256 quantity) internal virtual {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) _revert(MintToZeroAddress.selector);
        if (quantity == 0) _revert(MintZeroQuantity.selector);
        if (quantity > _MAX_MINT_ERC2309_QUANTITY_LIMIT) _revert(MintERC2309QuantityExceedsLimit.selector);

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

        // Overflows are unrealistic due to the above check for `quantity` to be below the limit.
        unchecked {
            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the `balance` and `numberMinted`.
            _packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);

            // Updates:
            // - `address` to the owner.
            // - `startTimestamp` to the timestamp of minting.
            // - `burned` to `false`.
            // - `nextInitialized` to `quantity == 1`.
            _packedOwnerships[startTokenId] =
                _packOwnershipData(to, _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0));

            if (startTokenId + quantity - 1 > _sequentialUpTo()) _revert(SequentialMintExceedsLimit.selector);

            emit ConsecutiveTransfer(startTokenId, startTokenId + quantity - 1, address(0), to);

            _currentIndex = startTokenId + quantity;
        }
        _afterTokenTransfers(address(0), to, startTokenId, 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.
     *
     * See {_mint}.
     *
     * Emits a {Transfer} event for each mint.
     */
    function _safeMint(address to, uint256 quantity, bytes memory _data) internal virtual {
        _mint(to, quantity);

        unchecked {
            if (to.code.length != 0) {
                uint256 end = _currentIndex;
                uint256 index = end - quantity;
                do {
                    if (!_checkContractOnERC721Received(address(0), to, index++, _data)) {
                        _revert(TransferToNonERC721ReceiverImplementer.selector);
                    }
                } while (index < end);
                // This prevents reentrancy to `_safeMint`.
                // It does not prevent reentrancy to `_safeMintSpot`.
                if (_currentIndex != end) revert();
            }
        }
    }

    /**
     * @dev Equivalent to `_safeMint(to, quantity, '')`.
     */
    function _safeMint(address to, uint256 quantity) internal virtual {
        _safeMint(to, quantity, "");
    }

    /**
     * @dev Mints a single token at `tokenId`.
     *
     * Note: A spot-minted `tokenId` that has been burned can be re-minted again.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` must be greater than `_sequentialUpTo()`.
     * - `tokenId` must not exist.
     *
     * Emits a {Transfer} event for each mint.
     */
    function _mintSpot(address to, uint256 tokenId) internal virtual {
        if (tokenId <= _sequentialUpTo()) _revert(SpotMintTokenIdTooSmall.selector);
        uint256 prevOwnershipPacked = _packedOwnerships[tokenId];
        if (_packedOwnershipExists(prevOwnershipPacked)) _revert(TokenAlreadyExists.selector);

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

        // Overflows are incredibly unrealistic.
        // The `numberMinted` for `to` is incremented by 1, and has a max limit of 2**64 - 1.
        // `_spotMinted` is incremented by 1, and has a max limit of 2**256 - 1.
        unchecked {
            // Updates:
            // - `address` to the owner.
            // - `startTimestamp` to the timestamp of minting.
            // - `burned` to `false`.
            // - `nextInitialized` to `true` (as `quantity == 1`).
            _packedOwnerships[tokenId] =
                _packOwnershipData(to, _nextInitializedFlag(1) | _nextExtraData(address(0), to, prevOwnershipPacked));

            // Updates:
            // - `balance += 1`.
            // - `numberMinted += 1`.
            //
            // We can directly add to the `balance` and `numberMinted`.
            _packedAddressData[to] += (1 << _BITPOS_NUMBER_MINTED) | 1;

            // Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
            uint256 toMasked = uint256(uint160(to)) & _BITMASK_ADDRESS;

            if (toMasked == 0) _revert(MintToZeroAddress.selector);

            assembly {
                // Emit the `Transfer` event.
                log4(
                    0, // Start of data (0, since no data).
                    0, // End of data (0, since no data).
                    _TRANSFER_EVENT_SIGNATURE, // Signature.
                    0, // `address(0)`.
                    toMasked, // `to`.
                    tokenId // `tokenId`.
                )
            }

            ++_spotMinted;
        }

        _afterTokenTransfers(address(0), to, tokenId, 1);
    }

    /**
     * @dev Safely mints a single token at `tokenId`.
     *
     * Note: A spot-minted `tokenId` that has been burned can be re-minted again.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}.
     * - `tokenId` must be greater than `_sequentialUpTo()`.
     * - `tokenId` must not exist.
     *
     * See {_mintSpot}.
     *
     * Emits a {Transfer} event.
     */
    function _safeMintSpot(address to, uint256 tokenId, bytes memory _data) internal virtual {
        _mintSpot(to, tokenId);

        unchecked {
            if (to.code.length != 0) {
                uint256 currentSpotMinted = _spotMinted;
                if (!_checkContractOnERC721Received(address(0), to, tokenId, _data)) {
                    _revert(TransferToNonERC721ReceiverImplementer.selector);
                }
                // This prevents reentrancy to `_safeMintSpot`.
                // It does not prevent reentrancy to `_safeMint`.
                if (_spotMinted != currentSpotMinted) revert();
            }
        }
    }

    /**
     * @dev Equivalent to `_safeMintSpot(to, tokenId, '')`.
     */
    function _safeMintSpot(address to, uint256 tokenId) internal virtual {
        _safeMintSpot(to, tokenId, "");
    }

    // =============================================================
    //                       APPROVAL OPERATIONS
    // =============================================================

    /**
     * @dev Equivalent to `_approve(to, tokenId, false)`.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _approve(to, tokenId, false);
    }

    /**
     * @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:
     *
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function _approve(address to, uint256 tokenId, bool approvalCheck) internal virtual {
        address owner = ownerOf(tokenId);

        if (approvalCheck && _msgSenderERC721A() != owner) {
            if (!isApprovedForAll(owner, _msgSenderERC721A())) {
                _revert(ApprovalCallerNotOwnerNorApproved.selector);
            }
        }

        _tokenApprovals[tokenId].value = to;
        emit Approval(owner, to, tokenId);
    }

    // =============================================================
    //                        BURN OPERATIONS
    // =============================================================

    /**
     * @dev 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 {
        uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

        address from = address(uint160(prevOwnershipPacked));

        (uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);

        if (approvalCheck) {
            // The nested ifs save around 20+ gas over a compound boolean condition.
            if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A())) {
                if (!isApprovedForAll(from, _msgSenderERC721A())) _revert(TransferCallerNotOwnerNorApproved.selector);
            }
        }

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

        // Clear approvals from the previous owner.
        assembly {
            if approvedAddress {
                // This is equivalent to `delete _tokenApprovals[tokenId]`.
                sstore(approvedAddressSlot, 0)
            }
        }

        // 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 {
            // Updates:
            // - `balance -= 1`.
            // - `numberBurned += 1`.
            //
            // We can directly decrement the balance, and increment the number burned.
            // This is equivalent to `packed -= 1; packed += 1 << _BITPOS_NUMBER_BURNED;`.
            _packedAddressData[from] += (1 << _BITPOS_NUMBER_BURNED) - 1;

            // Updates:
            // - `address` to the last owner.
            // - `startTimestamp` to the timestamp of burning.
            // - `burned` to `true`.
            // - `nextInitialized` to `true`.
            _packedOwnerships[tokenId] = _packOwnershipData(
                from,
                (_BITMASK_BURNED | _BITMASK_NEXT_INITIALIZED) | _nextExtraData(from, address(0), prevOwnershipPacked)
            );

            // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
            if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
                uint256 nextTokenId = tokenId + 1;
                // If the next slot's address is zero and not burned (i.e. packed value is zero).
                if (_packedOwnerships[nextTokenId] == 0) {
                    // If the next slot is within bounds.
                    if (nextTokenId != _currentIndex) {
                        // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                        _packedOwnerships[nextTokenId] = prevOwnershipPacked;
                    }
                }
            }
        }

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

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

    // =============================================================
    //                     EXTRA DATA OPERATIONS
    // =============================================================

    /**
     * @dev Directly sets the extra data for the ownership data `index`.
     */
    function _setExtraDataAt(uint256 index, uint24 extraData) internal virtual {
        uint256 packed = _packedOwnerships[index];
        if (packed == 0) _revert(OwnershipNotInitializedForExtraData.selector);
        uint256 extraDataCasted;
        // Cast `extraData` with assembly to avoid redundant masking.
        assembly {
            extraDataCasted := extraData
        }
        packed = (packed & _BITMASK_EXTRA_DATA_COMPLEMENT) | (extraDataCasted << _BITPOS_EXTRA_DATA);
        _packedOwnerships[index] = packed;
    }

    /**
     * @dev Called during each token transfer to set the 24bit `extraData` field.
     * Intended to be overridden by the cosumer contract.
     *
     * `previousExtraData` - the value of `extraData` before transfer.
     *
     * 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 _extraData(address from, address to, uint24 previousExtraData) internal view virtual returns (uint24) { }

    /**
     * @dev Returns the next extra data for the packed ownership data.
     * The returned result is shifted into position.
     */
    function _nextExtraData(address from, address to, uint256 prevOwnershipPacked) private view returns (uint256) {
        uint24 extraData = uint24(prevOwnershipPacked >> _BITPOS_EXTRA_DATA);
        return uint256(_extraData(from, to, extraData)) << _BITPOS_EXTRA_DATA;
    }

    // =============================================================
    //                       OTHER OPERATIONS
    // =============================================================

    /**
     * @dev Returns the message sender (defaults to `msg.sender`).
     *
     * If you are writing GSN compatible contracts, you need to override this function.
     */
    function _msgSenderERC721A() internal view virtual returns (address) {
        return msg.sender;
    }

    /**
     * @dev Converts a uint256 to its ASCII string decimal representation.
     */
    function _toString(uint256 value) internal pure virtual returns (string memory str) {
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit), but
            // we allocate 0xa0 bytes to keep the free memory pointer 32-byte word aligned.
            // We will need 1 word for the trailing zeros padding, 1 word for the length,
            // and 3 words for a maximum of 78 digits. Total: 5 * 0x20 = 0xa0.
            let m := add(mload(0x40), 0xa0)
            // Update the free memory pointer to allocate.
            mstore(0x40, m)
            // Assign the `str` to the end.
            str := sub(m, 0x20)
            // Zeroize the slot after the string.
            mstore(str, 0)

            // Cache the end of the memory to calculate the length later.
            let end := str

            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            // prettier-ignore
            for { let temp := value } 1 { } {
                str := sub(str, 1)
                // Write the character to the pointer.
                // The ASCII index of the '0' character is 48.
                mstore8(str, add(48, mod(temp, 10)))
                // Keep dividing `temp` until zero.
                temp := div(temp, 10)
                // prettier-ignore
                if iszero(temp) { break }
            }

            let length := sub(end, str)
            // Move the pointer 32 bytes leftwards to make room for the length.
            str := sub(str, 0x20)
            // Store the length.
            mstore(str, length)
        }
    }

    /**
     * @dev For more efficient reverts.
     */
    function _revert(bytes4 errorSelector) internal pure {
        assembly {
            mstore(0x00, errorSelector)
            revert(0x00, 0x04)
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Simple single owner authorization mixin.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)
///
/// @dev Note:
/// This implementation does NOT auto-initialize the owner to `msg.sender`.
/// You MUST call the `_initializeOwner` in the constructor / initializer.
///
/// While the ownable portion follows
/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,
/// the nomenclature for the 2-step ownership handover may be unique to this codebase.
abstract contract Ownable {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The caller is not authorized to call the function.
    error Unauthorized();

    /// @dev The `newOwner` cannot be the zero address.
    error NewOwnerIsZeroAddress();

    /// @dev The `pendingOwner` does not have a valid handover request.
    error NoHandoverRequest();

    /// @dev Cannot double-initialize.
    error AlreadyInitialized();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           EVENTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The ownership is transferred from `oldOwner` to `newOwner`.
    /// This event is intentionally kept the same as OpenZeppelin's Ownable to be
    /// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),
    /// despite it not being as lightweight as a single argument event.
    event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);

    /// @dev An ownership handover to `pendingOwner` has been requested.
    event OwnershipHandoverRequested(address indexed pendingOwner);

    /// @dev The ownership handover to `pendingOwner` has been canceled.
    event OwnershipHandoverCanceled(address indexed pendingOwner);

    /// @dev `keccak256(bytes("OwnershipTransferred(address,address)"))`.
    uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =
        0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;

    /// @dev `keccak256(bytes("OwnershipHandoverRequested(address)"))`.
    uint256 private constant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =
        0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;

    /// @dev `keccak256(bytes("OwnershipHandoverCanceled(address)"))`.
    uint256 private constant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =
        0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STORAGE                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The owner slot is given by:
    /// `bytes32(~uint256(uint32(bytes4(keccak256("_OWNER_SLOT_NOT")))))`.
    /// It is intentionally chosen to be a high value
    /// to avoid collision with lower slots.
    /// The choice of manual storage layout is to enable compatibility
    /// with both regular and upgradeable contracts.
    bytes32 internal constant _OWNER_SLOT =
        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927;

    /// The ownership handover slot of `newOwner` is given by:
    /// ```
    ///     mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED))
    ///     let handoverSlot := keccak256(0x00, 0x20)
    /// ```
    /// It stores the expiry timestamp of the two-step ownership handover.
    uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     INTERNAL FUNCTIONS                     */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Override to return true to make `_initializeOwner` prevent double-initialization.
    function _guardInitializeOwner() internal pure virtual returns (bool guard) {}

    /// @dev Initializes the owner directly without authorization guard.
    /// This function must be called upon initialization,
    /// regardless of whether the contract is upgradeable or not.
    /// This is to enable generalization to both regular and upgradeable contracts,
    /// and to save gas in case the initial owner is not the caller.
    /// For performance reasons, this function will not check if there
    /// is an existing owner.
    function _initializeOwner(address newOwner) internal virtual {
        if (_guardInitializeOwner()) {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                if sload(ownerSlot) {
                    mstore(0x00, 0x0dc149f0) // `AlreadyInitialized()`.
                    revert(0x1c, 0x04)
                }
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Store the new value.
                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
            }
        } else {
            /// @solidity memory-safe-assembly
            assembly {
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Store the new value.
                sstore(_OWNER_SLOT, newOwner)
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
            }
        }
    }

    /// @dev Sets the owner directly without authorization guard.
    function _setOwner(address newOwner) internal virtual {
        if (_guardInitializeOwner()) {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
                // Store the new value.
                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
            }
        } else {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
                // Store the new value.
                sstore(ownerSlot, newOwner)
            }
        }
    }

    /// @dev Throws if the sender is not the owner.
    function _checkOwner() internal view virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // If the caller is not the stored owner, revert.
            if iszero(eq(caller(), sload(_OWNER_SLOT))) {
                mstore(0x00, 0x82b42900) // `Unauthorized()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Returns how long a two-step ownership handover is valid for in seconds.
    /// Override to return a different value if needed.
    /// Made internal to conserve bytecode. Wrap it in a public function if needed.
    function _ownershipHandoverValidFor() internal view virtual returns (uint64) {
        return 48 * 3600;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  PUBLIC UPDATE FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Allows the owner to transfer the ownership to `newOwner`.
    function transferOwnership(address newOwner) public payable virtual onlyOwner {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(shl(96, newOwner)) {
                mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`.
                revert(0x1c, 0x04)
            }
        }
        _setOwner(newOwner);
    }

    /// @dev Allows the owner to renounce their ownership.
    function renounceOwnership() public payable virtual onlyOwner {
        _setOwner(address(0));
    }

    /// @dev Request a two-step ownership handover to the caller.
    /// The request will automatically expire in 48 hours (172800 seconds) by default.
    function requestOwnershipHandover() public payable virtual {
        unchecked {
            uint256 expires = block.timestamp + _ownershipHandoverValidFor();
            /// @solidity memory-safe-assembly
            assembly {
                // Compute and set the handover slot to `expires`.
                mstore(0x0c, _HANDOVER_SLOT_SEED)
                mstore(0x00, caller())
                sstore(keccak256(0x0c, 0x20), expires)
                // Emit the {OwnershipHandoverRequested} event.
                log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())
            }
        }
    }

    /// @dev Cancels the two-step ownership handover to the caller, if any.
    function cancelOwnershipHandover() public payable virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute and set the handover slot to 0.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, caller())
            sstore(keccak256(0x0c, 0x20), 0)
            // Emit the {OwnershipHandoverCanceled} event.
            log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())
        }
    }

    /// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`.
    /// Reverts if there is no existing ownership handover requested by `pendingOwner`.
    function completeOwnershipHandover(address pendingOwner) public payable virtual onlyOwner {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute and set the handover slot to 0.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, pendingOwner)
            let handoverSlot := keccak256(0x0c, 0x20)
            // If the handover does not exist, or has expired.
            if gt(timestamp(), sload(handoverSlot)) {
                mstore(0x00, 0x6f5e8818) // `NoHandoverRequest()`.
                revert(0x1c, 0x04)
            }
            // Set the handover slot to 0.
            sstore(handoverSlot, 0)
        }
        _setOwner(pendingOwner);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   PUBLIC READ FUNCTIONS                    */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the owner of the contract.
    function owner() public view virtual returns (address result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := sload(_OWNER_SLOT)
        }
    }

    /// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.
    function ownershipHandoverExpiresAt(address pendingOwner)
        public
        view
        virtual
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the handover slot.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, pendingOwner)
            // Load the handover slot.
            result := sload(keccak256(0x0c, 0x20))
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         MODIFIERS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Marks a function as only callable by the owner.
    modifier onlyOwner() virtual {
        _checkOwner();
        _;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Library for storage of packed unsigned integers.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibMap.sol)
library LibMap {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STRUCTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev A uint8 map in storage.
    struct Uint8Map {
        mapping(uint256 => uint256) map;
    }

    /// @dev A uint16 map in storage.
    struct Uint16Map {
        mapping(uint256 => uint256) map;
    }

    /// @dev A uint32 map in storage.
    struct Uint32Map {
        mapping(uint256 => uint256) map;
    }

    /// @dev A uint40 map in storage. Useful for storing timestamps up to 34841 A.D.
    struct Uint40Map {
        mapping(uint256 => uint256) map;
    }

    /// @dev A uint64 map in storage.
    struct Uint64Map {
        mapping(uint256 => uint256) map;
    }

    /// @dev A uint128 map in storage.
    struct Uint128Map {
        mapping(uint256 => uint256) map;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     GETTERS / SETTERS                      */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the uint8 value at `index` in `map`.
    function get(Uint8Map storage map, uint256 index) internal view returns (uint8 result) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, map.slot)
            mstore(0x00, shr(5, index))
            result := byte(and(31, not(index)), sload(keccak256(0x00, 0x40)))
        }
    }

    /// @dev Updates the uint8 value at `index` in `map`.
    function set(Uint8Map storage map, uint256 index, uint8 value) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, map.slot)
            mstore(0x00, shr(5, index))
            let s := keccak256(0x00, 0x40) // Storage slot.
            mstore(0x00, sload(s))
            mstore8(and(31, not(index)), value)
            sstore(s, mload(0x00))
        }
    }

    /// @dev Returns the uint16 value at `index` in `map`.
    function get(Uint16Map storage map, uint256 index) internal view returns (uint16 result) {
        result = uint16(map.map[index >> 4] >> ((index & 15) << 4));
    }

    /// @dev Updates the uint16 value at `index` in `map`.
    function set(Uint16Map storage map, uint256 index, uint16 value) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, map.slot)
            mstore(0x00, shr(4, index))
            let s := keccak256(0x00, 0x40) // Storage slot.
            let o := shl(4, and(index, 15)) // Storage slot offset (bits).
            let v := sload(s) // Storage slot value.
            let m := 0xffff // Value mask.
            sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value)))))
        }
    }

    /// @dev Returns the uint32 value at `index` in `map`.
    function get(Uint32Map storage map, uint256 index) internal view returns (uint32 result) {
        result = uint32(map.map[index >> 3] >> ((index & 7) << 5));
    }

    /// @dev Updates the uint32 value at `index` in `map`.
    function set(Uint32Map storage map, uint256 index, uint32 value) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, map.slot)
            mstore(0x00, shr(3, index))
            let s := keccak256(0x00, 0x40) // Storage slot.
            let o := shl(5, and(index, 7)) // Storage slot offset (bits).
            let v := sload(s) // Storage slot value.
            let m := 0xffffffff // Value mask.
            sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value)))))
        }
    }

    /// @dev Returns the uint40 value at `index` in `map`.
    function get(Uint40Map storage map, uint256 index) internal view returns (uint40 result) {
        unchecked {
            result = uint40(map.map[index / 6] >> ((index % 6) * 40));
        }
    }

    /// @dev Updates the uint40 value at `index` in `map`.
    function set(Uint40Map storage map, uint256 index, uint40 value) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, map.slot)
            mstore(0x00, div(index, 6))
            let s := keccak256(0x00, 0x40) // Storage slot.
            let o := mul(40, mod(index, 6)) // Storage slot offset (bits).
            let v := sload(s) // Storage slot value.
            let m := 0xffffffffff // Value mask.
            sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value)))))
        }
    }

    /// @dev Returns the uint64 value at `index` in `map`.
    function get(Uint64Map storage map, uint256 index) internal view returns (uint64 result) {
        result = uint64(map.map[index >> 2] >> ((index & 3) << 6));
    }

    /// @dev Updates the uint64 value at `index` in `map`.
    function set(Uint64Map storage map, uint256 index, uint64 value) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, map.slot)
            mstore(0x00, shr(2, index))
            let s := keccak256(0x00, 0x40) // Storage slot.
            let o := shl(6, and(index, 3)) // Storage slot offset (bits).
            let v := sload(s) // Storage slot value.
            let m := 0xffffffffffffffff // Value mask.
            sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value)))))
        }
    }

    /// @dev Returns the uint128 value at `index` in `map`.
    function get(Uint128Map storage map, uint256 index) internal view returns (uint128 result) {
        result = uint128(map.map[index >> 1] >> ((index & 1) << 7));
    }

    /// @dev Updates the uint128 value at `index` in `map`.
    function set(Uint128Map storage map, uint256 index, uint128 value) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, map.slot)
            mstore(0x00, shr(1, index))
            let s := keccak256(0x00, 0x40) // Storage slot.
            let o := shl(7, and(index, 1)) // Storage slot offset (bits).
            let v := sload(s) // Storage slot value.
            let m := 0xffffffffffffffffffffffffffffffff // Value mask.
            sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value)))))
        }
    }

    /// @dev Returns the value at `index` in `map`.
    function get(mapping(uint256 => uint256) storage map, uint256 index, uint256 bitWidth)
        internal
        view
        returns (uint256 result)
    {
        unchecked {
            uint256 d = _rawDiv(256, bitWidth); // Bucket size.
            uint256 m = (1 << bitWidth) - 1; // Value mask.
            result = (map[_rawDiv(index, d)] >> (_rawMod(index, d) * bitWidth)) & m;
        }
    }

    /// @dev Updates the value at `index` in `map`.
    function set(
        mapping(uint256 => uint256) storage map,
        uint256 index,
        uint256 value,
        uint256 bitWidth
    ) internal {
        unchecked {
            uint256 d = _rawDiv(256, bitWidth); // Bucket size.
            uint256 m = (1 << bitWidth) - 1; // Value mask.
            uint256 o = _rawMod(index, d) * bitWidth; // Storage slot offset (bits).
            map[_rawDiv(index, d)] ^= (((map[_rawDiv(index, d)] >> o) ^ value) & m) << o;
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       BINARY SEARCH                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    // The following functions search in the range of [`start`, `end`)
    // (i.e. `start <= index < end`).
    // The range must be sorted in ascending order.
    // `index` precedence: equal to > nearest before > nearest after.
    // An invalid search range will simply return `(found = false, index = start)`.

    /// @dev Returns whether `map` contains `needle`, and the index of `needle`.
    function searchSorted(Uint8Map storage map, uint8 needle, uint256 start, uint256 end)
        internal
        view
        returns (bool found, uint256 index)
    {
        return searchSorted(map.map, needle, start, end, 8);
    }

    /// @dev Returns whether `map` contains `needle`, and the index of `needle`.
    function searchSorted(Uint16Map storage map, uint16 needle, uint256 start, uint256 end)
        internal
        view
        returns (bool found, uint256 index)
    {
        return searchSorted(map.map, needle, start, end, 16);
    }

    /// @dev Returns whether `map` contains `needle`, and the index of `needle`.
    function searchSorted(Uint32Map storage map, uint32 needle, uint256 start, uint256 end)
        internal
        view
        returns (bool found, uint256 index)
    {
        return searchSorted(map.map, needle, start, end, 32);
    }

    /// @dev Returns whether `map` contains `needle`, and the index of `needle`.
    function searchSorted(Uint40Map storage map, uint40 needle, uint256 start, uint256 end)
        internal
        view
        returns (bool found, uint256 index)
    {
        return searchSorted(map.map, needle, start, end, 40);
    }

    /// @dev Returns whether `map` contains `needle`, and the index of `needle`.
    function searchSorted(Uint64Map storage map, uint64 needle, uint256 start, uint256 end)
        internal
        view
        returns (bool found, uint256 index)
    {
        return searchSorted(map.map, needle, start, end, 64);
    }

    /// @dev Returns whether `map` contains `needle`, and the index of `needle`.
    function searchSorted(Uint128Map storage map, uint128 needle, uint256 start, uint256 end)
        internal
        view
        returns (bool found, uint256 index)
    {
        return searchSorted(map.map, needle, start, end, 128);
    }

    /// @dev Returns whether `map` contains `needle`, and the index of `needle`.
    function searchSorted(
        mapping(uint256 => uint256) storage map,
        uint256 needle,
        uint256 start,
        uint256 end,
        uint256 bitWidth
    ) internal view returns (bool found, uint256 index) {
        unchecked {
            if (start >= end) end = start;
            uint256 t;
            uint256 o = start - 1; // Offset to derive the actual index.
            uint256 l = 1; // Low.
            uint256 d = _rawDiv(256, bitWidth); // Bucket size.
            uint256 m = (1 << bitWidth) - 1; // Value mask.
            uint256 h = end - start; // High.
            while (true) {
                index = (l & h) + ((l ^ h) >> 1);
                if (l > h) break;
                t = (map[_rawDiv(index + o, d)] >> (_rawMod(index + o, d) * bitWidth)) & m;
                if (t == needle) break;
                if (needle <= t) h = index - 1;
                else l = index + 1;
            }
            /// @solidity memory-safe-assembly
            assembly {
                m := or(iszero(index), iszero(bitWidth))
                found := iszero(or(xor(t, needle), m))
                index := add(o, xor(index, mul(xor(index, 1), m)))
            }
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                      PRIVATE HELPERS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns `x / y`, returning 0 if `y` is zero.
    function _rawDiv(uint256 x, uint256 y) private pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := div(x, y)
        }
    }

    /// @dev Returns `x % y`, returning 0 if `y` is zero.
    function _rawMod(uint256 x, uint256 y) private pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := mod(x, y)
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

import { LibBit } from "./LibBit.sol";

/// @notice Library for storage of packed unsigned booleans.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibBitmap.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibBitmap.sol)
/// @author Modified from Solidity-Bits
/// (https://github.com/estarriolvetch/solidity-bits/blob/main/contracts/BitMaps.sol)
library LibBitmap {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The constant returned when a bitmap scan does not find a result.
    uint256 internal constant NOT_FOUND = type(uint256).max;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STRUCTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev A bitmap in storage.
    struct Bitmap {
        mapping(uint256 => uint256) map;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         OPERATIONS                         */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the boolean value of the bit at `index` in `bitmap`.
    function get(Bitmap storage bitmap, uint256 index) internal view returns (bool isSet) {
        // It is better to set `isSet` to either 0 or 1, than zero vs non-zero.
        // Both cost the same amount of gas, but the former allows the returned value
        // to be reused without cleaning the upper bits.
        uint256 b = (bitmap.map[index >> 8] >> (index & 0xff)) & 1;
        /// @solidity memory-safe-assembly
        assembly {
            isSet := b
        }
    }

    /// @dev Updates the bit at `index` in `bitmap` to true.
    function set(Bitmap storage bitmap, uint256 index) internal {
        bitmap.map[index >> 8] |= (1 << (index & 0xff));
    }

    /// @dev Updates the bit at `index` in `bitmap` to false.
    function unset(Bitmap storage bitmap, uint256 index) internal {
        bitmap.map[index >> 8] &= ~(1 << (index & 0xff));
    }

    /// @dev Flips the bit at `index` in `bitmap`.
    /// Returns the boolean result of the flipped bit.
    function toggle(Bitmap storage bitmap, uint256 index) internal returns (bool newIsSet) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, bitmap.slot)
            mstore(0x00, shr(8, index))
            let storageSlot := keccak256(0x00, 0x40)
            let shift := and(index, 0xff)
            let storageValue := xor(sload(storageSlot), shl(shift, 1))
            // It makes sense to return the `newIsSet`,
            // as it allow us to skip an additional warm `sload`,
            // and it costs minimal gas (about 15),
            // which may be optimized away if the returned value is unused.
            newIsSet := and(1, shr(shift, storageValue))
            sstore(storageSlot, storageValue)
        }
    }

    /// @dev Updates the bit at `index` in `bitmap` to `shouldSet`.
    function setTo(Bitmap storage bitmap, uint256 index, bool shouldSet) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, bitmap.slot)
            mstore(0x00, shr(8, index))
            let storageSlot := keccak256(0x00, 0x40)
            let storageValue := sload(storageSlot)
            let shift := and(index, 0xff)
            sstore(
                storageSlot,
                // Unsets the bit at `shift` via `and`, then sets its new value via `or`.
                or(and(storageValue, not(shl(shift, 1))), shl(shift, iszero(iszero(shouldSet))))
            )
        }
    }

    /// @dev Consecutively sets `amount` of bits starting from the bit at `start`.
    function setBatch(Bitmap storage bitmap, uint256 start, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let max := not(0)
            let shift := and(start, 0xff)
            mstore(0x20, bitmap.slot)
            mstore(0x00, shr(8, start))
            if iszero(lt(add(shift, amount), 257)) {
                let storageSlot := keccak256(0x00, 0x40)
                sstore(storageSlot, or(sload(storageSlot), shl(shift, max)))
                let bucket := add(mload(0x00), 1)
                let bucketEnd := add(mload(0x00), shr(8, add(amount, shift)))
                amount := and(add(amount, shift), 0xff)
                shift := 0
                for { } iszero(eq(bucket, bucketEnd)) { bucket := add(bucket, 1) } {
                    mstore(0x00, bucket)
                    sstore(keccak256(0x00, 0x40), max)
                }
                mstore(0x00, bucket)
            }
            let storageSlot := keccak256(0x00, 0x40)
            sstore(storageSlot, or(sload(storageSlot), shl(shift, shr(sub(256, amount), max))))
        }
    }

    /// @dev Consecutively unsets `amount` of bits starting from the bit at `start`.
    function unsetBatch(Bitmap storage bitmap, uint256 start, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let shift := and(start, 0xff)
            mstore(0x20, bitmap.slot)
            mstore(0x00, shr(8, start))
            if iszero(lt(add(shift, amount), 257)) {
                let storageSlot := keccak256(0x00, 0x40)
                sstore(storageSlot, and(sload(storageSlot), not(shl(shift, not(0)))))
                let bucket := add(mload(0x00), 1)
                let bucketEnd := add(mload(0x00), shr(8, add(amount, shift)))
                amount := and(add(amount, shift), 0xff)
                shift := 0
                for { } iszero(eq(bucket, bucketEnd)) { bucket := add(bucket, 1) } {
                    mstore(0x00, bucket)
                    sstore(keccak256(0x00, 0x40), 0)
                }
                mstore(0x00, bucket)
            }
            let storageSlot := keccak256(0x00, 0x40)
            sstore(storageSlot, and(sload(storageSlot), not(shl(shift, shr(sub(256, amount), not(0))))))
        }
    }

    /// @dev Returns number of set bits within a range by
    /// scanning `amount` of bits starting from the bit at `start`.
    function popCount(Bitmap storage bitmap, uint256 start, uint256 amount) internal view returns (uint256 count) {
        unchecked {
            uint256 bucket = start >> 8;
            uint256 shift = start & 0xff;
            if (!(amount + shift < 257)) {
                count = LibBit.popCount(bitmap.map[bucket] >> shift);
                uint256 bucketEnd = bucket + ((amount + shift) >> 8);
                amount = (amount + shift) & 0xff;
                shift = 0;
                for (++bucket; bucket != bucketEnd; ++bucket) {
                    count += LibBit.popCount(bitmap.map[bucket]);
                }
            }
            count += LibBit.popCount((bitmap.map[bucket] >> shift) << (256 - amount));
        }
    }

    /// @dev Returns the index of the most significant set bit in `[0..upTo]`.
    /// If no set bit is found, returns `NOT_FOUND`.
    function findLastSet(Bitmap storage bitmap, uint256 upTo) internal view returns (uint256 setBitIndex) {
        setBitIndex = NOT_FOUND;
        uint256 bucket = upTo >> 8;
        uint256 bits;
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, bucket)
            mstore(0x20, bitmap.slot)
            let offset := and(0xff, not(upTo)) // `256 - (255 & upTo) - 1`.
            bits := shr(offset, shl(offset, sload(keccak256(0x00, 0x40))))
            if iszero(or(bits, iszero(bucket))) {
                for { } 1 { } {
                    bucket := add(bucket, setBitIndex) // `sub(bucket, 1)`.
                    mstore(0x00, bucket)
                    bits := sload(keccak256(0x00, 0x40))
                    if or(bits, iszero(bucket)) { break }
                }
            }
        }
        if (bits != 0) {
            setBitIndex = (bucket << 8) | LibBit.fls(bits);
            /// @solidity memory-safe-assembly
            assembly {
                setBitIndex := or(setBitIndex, sub(0, gt(setBitIndex, upTo)))
            }
        }
    }

    /// @dev Returns the index of the least significant unset bit in `[begin..upTo]`.
    /// If no unset bit is found, returns `NOT_FOUND`.
    function findFirstUnset(
        Bitmap storage bitmap,
        uint256 begin,
        uint256 upTo
    )
        internal
        view
        returns (uint256 unsetBitIndex)
    {
        unsetBitIndex = NOT_FOUND;
        uint256 bucket = begin >> 8;
        uint256 negBits;
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, bucket)
            mstore(0x20, bitmap.slot)
            let offset := and(0xff, begin)
            negBits := shl(offset, shr(offset, not(sload(keccak256(0x00, 0x40)))))
            if iszero(negBits) {
                let lastBucket := shr(8, upTo)
                for { } 1 { } {
                    bucket := add(bucket, 1)
                    mstore(0x00, bucket)
                    negBits := not(sload(keccak256(0x00, 0x40)))
                    if or(negBits, gt(bucket, lastBucket)) { break }
                }
                if gt(bucket, lastBucket) { negBits := shl(and(0xff, not(upTo)), shr(and(0xff, not(upTo)), negBits)) }
            }
        }
        if (negBits != 0) {
            uint256 r = (bucket << 8) | LibBit.ffs(negBits);
            /// @solidity memory-safe-assembly
            assembly {
                unsetBitIndex := or(r, sub(0, or(gt(r, upTo), lt(r, begin))))
            }
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Library for managing enumerable sets in storage.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/EnumerableSetLib.sol)
///
/// @dev Note:
/// In many applications, the number of elements in an enumerable set is small.
/// This enumerable set implementation avoids storing the length and indices
/// for up to 3 elements. Once the length exceeds 3 for the first time, the length
/// and indices will be initialized. The amortized cost of adding elements is O(1).
///
/// The AddressSet implementation packs the length with the 0th entry.
library EnumerableSetLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The index must be less than the length.
    error IndexOutOfBounds();

    /// @dev The value cannot be the zero sentinel.
    error ValueIsZeroSentinel();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev A sentinel value to denote the zero value in storage.
    /// No elements can be equal to this value.
    /// `uint72(bytes9(keccak256(bytes("_ZERO_SENTINEL"))))`.
    uint256 private constant _ZERO_SENTINEL = 0xfbb67fda52d4bfb8bf;

    /// @dev The storage layout is given by:
    /// ```
    ///     mstore(0x04, _ENUMERABLE_ADDRESS_SET_SLOT_SEED)
    ///     mstore(0x00, set.slot)
    ///     let rootSlot := keccak256(0x00, 0x24)
    ///     mstore(0x20, rootSlot)
    ///     mstore(0x00, shr(96, shl(96, value)))
    ///     let positionSlot := keccak256(0x00, 0x40)
    ///     let valueSlot := add(rootSlot, sload(positionSlot))
    ///     let valueInStorage := shr(96, sload(valueSlot))
    ///     let lazyLength := shr(160, shl(160, sload(rootSlot)))
    /// ```
    uint256 private constant _ENUMERABLE_ADDRESS_SET_SLOT_SEED = 0x978aab92;

    /// @dev The storage layout is given by:
    /// ```
    ///     mstore(0x04, _ENUMERABLE_WORD_SET_SLOT_SEED)
    ///     mstore(0x00, set.slot)
    ///     let rootSlot := keccak256(0x00, 0x24)
    ///     mstore(0x20, rootSlot)
    ///     mstore(0x00, value)
    ///     let positionSlot := keccak256(0x00, 0x40)
    ///     let valueSlot := add(rootSlot, sload(positionSlot))
    ///     let valueInStorage := sload(valueSlot)
    ///     let lazyLength := sload(not(rootSlot))
    /// ```
    uint256 private constant _ENUMERABLE_WORD_SET_SLOT_SEED = 0x18fb5864;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STRUCTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev An enumerable address set in storage.
    struct AddressSet {
        uint256 _spacer;
    }

    /// @dev An enumerable bytes32 set in storage.
    struct Bytes32Set {
        uint256 _spacer;
    }

    /// @dev An enumerable uint256 set in storage.
    struct Uint256Set {
        uint256 _spacer;
    }

    /// @dev An enumerable int256 set in storage.
    struct Int256Set {
        uint256 _spacer;
    }

    /// @dev An enumerable uint8 set in storage. Useful for enums.
    struct Uint8Set {
        uint256 data;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     GETTERS / SETTERS                      */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the number of elements in the set.
    function length(AddressSet storage set) internal view returns (uint256 result) {
        bytes32 rootSlot = _rootSlot(set);
        /// @solidity memory-safe-assembly
        assembly {
            let rootPacked := sload(rootSlot)
            let n := shr(160, shl(160, rootPacked))
            result := shr(1, n)
            for {} iszero(or(iszero(shr(96, rootPacked)), n)) {} {
                result := 1
                if iszero(sload(add(rootSlot, result))) { break }
                result := 2
                if iszero(sload(add(rootSlot, result))) { break }
                result := 3
                break
            }
        }
    }

    /// @dev Returns the number of elements in the set.
    function length(Bytes32Set storage set) internal view returns (uint256 result) {
        bytes32 rootSlot = _rootSlot(set);
        /// @solidity memory-safe-assembly
        assembly {
            let n := sload(not(rootSlot))
            result := shr(1, n)
            for {} iszero(n) {} {
                result := 0
                if iszero(sload(add(rootSlot, result))) { break }
                result := 1
                if iszero(sload(add(rootSlot, result))) { break }
                result := 2
                if iszero(sload(add(rootSlot, result))) { break }
                result := 3
                break
            }
        }
    }

    /// @dev Returns the number of elements in the set.
    function length(Uint256Set storage set) internal view returns (uint256 result) {
        result = length(_toBytes32Set(set));
    }

    /// @dev Returns the number of elements in the set.
    function length(Int256Set storage set) internal view returns (uint256 result) {
        result = length(_toBytes32Set(set));
    }

    /// @dev Returns the number of elements in the set.
    function length(Uint8Set storage set) internal view returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            for { let packed := sload(set.slot) } packed { result := add(1, result) } {
                packed := xor(packed, and(packed, add(1, not(packed))))
            }
        }
    }

    /// @dev Returns whether `value` is in the set.
    function contains(AddressSet storage set, address value) internal view returns (bool result) {
        bytes32 rootSlot = _rootSlot(set);
        /// @solidity memory-safe-assembly
        assembly {
            value := shr(96, shl(96, value))
            if eq(value, _ZERO_SENTINEL) {
                mstore(0x00, 0xf5a267f1) // `ValueIsZeroSentinel()`.
                revert(0x1c, 0x04)
            }
            if iszero(value) { value := _ZERO_SENTINEL }
            let rootPacked := sload(rootSlot)
            for {} 1 {} {
                if iszero(shr(160, shl(160, rootPacked))) {
                    result := 1
                    if eq(shr(96, rootPacked), value) { break }
                    if eq(shr(96, sload(add(rootSlot, 1))), value) { break }
                    if eq(shr(96, sload(add(rootSlot, 2))), value) { break }
                    result := 0
                    break
                }
                mstore(0x20, rootSlot)
                mstore(0x00, value)
                result := iszero(iszero(sload(keccak256(0x00, 0x40))))
                break
            }
        }
    }

    /// @dev Returns whether `value` is in the set.
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool result) {
        bytes32 rootSlot = _rootSlot(set);
        /// @solidity memory-safe-assembly
        assembly {
            if eq(value, _ZERO_SENTINEL) {
                mstore(0x00, 0xf5a267f1) // `ValueIsZeroSentinel()`.
                revert(0x1c, 0x04)
            }
            if iszero(value) { value := _ZERO_SENTINEL }
            for {} 1 {} {
                if iszero(sload(not(rootSlot))) {
                    result := 1
                    if eq(sload(rootSlot), value) { break }
                    if eq(sload(add(rootSlot, 1)), value) { break }
                    if eq(sload(add(rootSlot, 2)), value) { break }
                    result := 0
                    break
                }
                mstore(0x20, rootSlot)
                mstore(0x00, value)
                result := iszero(iszero(sload(keccak256(0x00, 0x40))))
                break
            }
        }
    }

    /// @dev Returns whether `value` is in the set.
    function contains(Uint256Set storage set, uint256 value) internal view returns (bool result) {
        result = contains(_toBytes32Set(set), bytes32(value));
    }

    /// @dev Returns whether `value` is in the set.
    function contains(Int256Set storage set, int256 value) internal view returns (bool result) {
        result = contains(_toBytes32Set(set), bytes32(uint256(value)));
    }

    /// @dev Returns whether `value` is in the set.
    function contains(Uint8Set storage set, uint8 value) internal view returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := and(1, shr(and(0xff, value), sload(set.slot)))
        }
    }

    /// @dev Adds `value` to the set. Returns whether `value` was not in the set.
    function add(AddressSet storage set, address value) internal returns (bool result) {
        bytes32 rootSlot = _rootSlot(set);
        /// @solidity memory-safe-assembly
        assembly {
            value := shr(96, shl(96, value))
            if eq(value, _ZERO_SENTINEL) {
                mstore(0x00, 0xf5a267f1) // `ValueIsZeroSentinel()`.
                revert(0x1c, 0x04)
            }
            if iszero(value) { value := _ZERO_SENTINEL }
            let rootPacked := sload(rootSlot)
            for { let n := shr(160, shl(160, rootPacked)) } 1 {} {
                mstore(0x20, rootSlot)
                if iszero(n) {
                    let v0 := shr(96, rootPacked)
                    if iszero(v0) {
                        sstore(rootSlot, shl(96, value))
                        result := 1
                        break
                    }
                    if eq(v0, value) { break }
                    let v1 := shr(96, sload(add(rootSlot, 1)))
                    if iszero(v1) {
                        sstore(add(rootSlot, 1), shl(96, value))
                        result := 1
                        break
                    }
                    if eq(v1, value) { break }
                    let v2 := shr(96, sload(add(rootSlot, 2)))
                    if iszero(v2) {
                        sstore(add(rootSlot, 2), shl(96, value))
                        result := 1
                        break
                    }
                    if eq(v2, value) { break }
                    mstore(0x00, v0)
                    sstore(keccak256(0x00, 0x40), 1)
                    mstore(0x00, v1)
                    sstore(keccak256(0x00, 0x40), 2)
                    mstore(0x00, v2)
                    sstore(keccak256(0x00, 0x40), 3)
                    rootPacked := or(rootPacked, 7)
                    n := 7
                }
                mstore(0x00, value)
                let p := keccak256(0x00, 0x40)
                if iszero(sload(p)) {
                    n := shr(1, n)
                    result := 1
                    sstore(p, add(1, n))
                    if iszero(n) {
                        sstore(rootSlot, or(3, shl(96, value)))
                        break
                    }
                    sstore(add(rootSlot, n), shl(96, value))
                    sstore(rootSlot, add(2, rootPacked))
                    break
                }
                break
            }
        }
    }

    /// @dev Adds `value` to the set. Returns whether `value` was not in the set.
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool result) {
        bytes32 rootSlot = _rootSlot(set);
        /// @solidity memory-safe-assembly
        assembly {
            if eq(value, _ZERO_SENTINEL) {
                mstore(0x00, 0xf5a267f1) // `ValueIsZeroSentinel()`.
                revert(0x1c, 0x04)
            }
            if iszero(value) { value := _ZERO_SENTINEL }
            for { let n := sload(not(rootSlot)) } 1 {} {
                mstore(0x20, rootSlot)
                if iszero(n) {
                    let v0 := sload(rootSlot)
                    if iszero(v0) {
                        sstore(rootSlot, value)
                        result := 1
                        break
                    }
                    if eq(v0, value) { break }
                    let v1 := sload(add(rootSlot, 1))
                    if iszero(v1) {
                        sstore(add(rootSlot, 1), value)
                        result := 1
                        break
                    }
                    if eq(v1, value) { break }
                    let v2 := sload(add(rootSlot, 2))
                    if iszero(v2) {
                        sstore(add(rootSlot, 2), value)
                        result := 1
                        break
                    }
                    if eq(v2, value) { break }
                    mstore(0x00, v0)
                    sstore(keccak256(0x00, 0x40), 1)
                    mstore(0x00, v1)
                    sstore(keccak256(0x00, 0x40), 2)
                    mstore(0x00, v2)
                    sstore(keccak256(0x00, 0x40), 3)
                    n := 7
                }
                mstore(0x00, value)
                let p := keccak256(0x00, 0x40)
                if iszero(sload(p)) {
                    n := shr(1, n)
                    sstore(add(rootSlot, n), value)
                    sstore(p, add(1, n))
                    sstore(not(rootSlot), or(1, shl(1, add(1, n))))
                    result := 1
                    break
                }
                break
            }
        }
    }

    /// @dev Adds `value` to the set. Returns whether `value` was not in the set.
    function add(Uint256Set storage set, uint256 value) internal returns (bool result) {
        result = add(_toBytes32Set(set), bytes32(value));
    }

    /// @dev Adds `value` to the set. Returns whether `value` was not in the set.
    function add(Int256Set storage set, int256 value) internal returns (bool result) {
        result = add(_toBytes32Set(set), bytes32(uint256(value)));
    }

    /// @dev Adds `value` to the set. Returns whether `value` was not in the set.
    function add(Uint8Set storage set, uint8 value) internal returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := sload(set.slot)
            let mask := shl(and(0xff, value), 1)
            sstore(set.slot, or(result, mask))
            result := iszero(and(result, mask))
        }
    }

    /// @dev Removes `value` from the set. Returns whether `value` was in the set.
    function remove(AddressSet storage set, address value) internal returns (bool result) {
        bytes32 rootSlot = _rootSlot(set);
        /// @solidity memory-safe-assembly
        assembly {
            value := shr(96, shl(96, value))
            if eq(value, _ZERO_SENTINEL) {
                mstore(0x00, 0xf5a267f1) // `ValueIsZeroSentinel()`.
                revert(0x1c, 0x04)
            }
            if iszero(value) { value := _ZERO_SENTINEL }
            let rootPacked := sload(rootSlot)
            for { let n := shr(160, shl(160, rootPacked)) } 1 {} {
                if iszero(n) {
                    result := 1
                    if eq(shr(96, rootPacked), value) {
                        sstore(rootSlot, sload(add(rootSlot, 1)))
                        sstore(add(rootSlot, 1), sload(add(rootSlot, 2)))
                        sstore(add(rootSlot, 2), 0)
                        break
                    }
                    if eq(shr(96, sload(add(rootSlot, 1))), value) {
                        sstore(add(rootSlot, 1), sload(add(rootSlot, 2)))
                        sstore(add(rootSlot, 2), 0)
                        break
                    }
                    if eq(shr(96, sload(add(rootSlot, 2))), value) {
                        sstore(add(rootSlot, 2), 0)
                        break
                    }
                    result := 0
                    break
                }
                mstore(0x20, rootSlot)
                mstore(0x00, value)
                let p := keccak256(0x00, 0x40)
                let position := sload(p)
                if iszero(position) { break }
                n := sub(shr(1, n), 1)
                if iszero(eq(sub(position, 1), n)) {
                    let lastValue := shr(96, sload(add(rootSlot, n)))
                    sstore(add(rootSlot, sub(position, 1)), shl(96, lastValue))
                    sstore(add(rootSlot, n), 0)
                    mstore(0x00, lastValue)
                    sstore(keccak256(0x00, 0x40), position)
                }
                sstore(rootSlot, or(shl(96, shr(96, sload(rootSlot))), or(shl(1, n), 1)))
                sstore(p, 0)
                result := 1
                break
            }
        }
    }

    /// @dev Removes `value` from the set. Returns whether `value` was in the set.
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool result) {
        bytes32 rootSlot = _rootSlot(set);
        /// @solidity memory-safe-assembly
        assembly {
            if eq(value, _ZERO_SENTINEL) {
                mstore(0x00, 0xf5a267f1) // `ValueIsZeroSentinel()`.
                revert(0x1c, 0x04)
            }
            if iszero(value) { value := _ZERO_SENTINEL }
            for { let n := sload(not(rootSlot)) } 1 {} {
                if iszero(n) {
                    result := 1
                    if eq(sload(rootSlot), value) {
                        sstore(rootSlot, sload(add(rootSlot, 1)))
                        sstore(add(rootSlot, 1), sload(add(rootSlot, 2)))
                        sstore(add(rootSlot, 2), 0)
                        break
                    }
                    if eq(sload(add(rootSlot, 1)), value) {
                        sstore(add(rootSlot, 1), sload(add(rootSlot, 2)))
                        sstore(add(rootSlot, 2), 0)
                        break
                    }
                    if eq(sload(add(rootSlot, 2)), value) {
                        sstore(add(rootSlot, 2), 0)
                        break
                    }
                    result := 0
                    break
                }
                mstore(0x20, rootSlot)
                mstore(0x00, value)
                let p := keccak256(0x00, 0x40)
                let position := sload(p)
                if iszero(position) { break }
                n := sub(shr(1, n), 1)
                if iszero(eq(sub(position, 1), n)) {
                    let lastValue := sload(add(rootSlot, n))
                    sstore(add(rootSlot, sub(position, 1)), lastValue)
                    sstore(add(rootSlot, n), 0)
                    mstore(0x00, lastValue)
                    sstore(keccak256(0x00, 0x40), position)
                }
                sstore(not(rootSlot), or(shl(1, n), 1))
                sstore(p, 0)
                result := 1
                break
            }
        }
    }

    /// @dev Removes `value` from the set. Returns whether `value` was in the set.
    function remove(Uint256Set storage set, uint256 value) internal returns (bool result) {
        result = remove(_toBytes32Set(set), bytes32(value));
    }

    /// @dev Removes `value` from the set. Returns whether `value` was in the set.
    function remove(Int256Set storage set, int256 value) internal returns (bool result) {
        result = remove(_toBytes32Set(set), bytes32(uint256(value)));
    }

    /// @dev Removes `value` from the set. Returns whether `value` was in the set.
    function remove(Uint8Set storage set, uint8 value) internal returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := sload(set.slot)
            let mask := shl(and(0xff, value), 1)
            sstore(set.slot, and(result, not(mask)))
            result := iszero(iszero(and(result, mask)))
        }
    }

    /// @dev Returns all of the values in the set.
    /// Note: This can consume more gas than the block gas limit for large sets.
    function values(AddressSet storage set) internal view returns (address[] memory result) {
        bytes32 rootSlot = _rootSlot(set);
        /// @solidity memory-safe-assembly
        assembly {
            let zs := _ZERO_SENTINEL
            let rootPacked := sload(rootSlot)
            let n := shr(160, shl(160, rootPacked))
            result := mload(0x40)
            let o := add(0x20, result)
            let v := shr(96, rootPacked)
            mstore(o, mul(v, iszero(eq(v, zs))))
            for {} 1 {} {
                if iszero(n) {
                    if v {
                        n := 1
                        v := shr(96, sload(add(rootSlot, n)))
                        if v {
                            n := 2
                            mstore(add(o, 0x20), mul(v, iszero(eq(v, zs))))
                            v := shr(96, sload(add(rootSlot, n)))
                            if v {
                                n := 3
                                mstore(add(o, 0x40), mul(v, iszero(eq(v, zs))))
                            }
                        }
                    }
                    break
                }
                n := shr(1, n)
                for { let i := 1 } lt(i, n) { i := add(i, 1) } {
                    v := shr(96, sload(add(rootSlot, i)))
                    mstore(add(o, shl(5, i)), mul(v, iszero(eq(v, zs))))
                }
                break
            }
            mstore(result, n)
            mstore(0x40, add(o, shl(5, n)))
        }
    }

    /// @dev Returns all of the values in the set.
    /// Note: This can consume more gas than the block gas limit for large sets.
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory result) {
        bytes32 rootSlot = _rootSlot(set);
        /// @solidity memory-safe-assembly
        assembly {
            let zs := _ZERO_SENTINEL
            let n := sload(not(rootSlot))
            result := mload(0x40)
            let o := add(0x20, result)
            for {} 1 {} {
                if iszero(n) {
                    let v := sload(rootSlot)
                    if v {
                        n := 1
                        mstore(o, mul(v, iszero(eq(v, zs))))
                        v := sload(add(rootSlot, n))
                        if v {
                            n := 2
                            mstore(add(o, 0x20), mul(v, iszero(eq(v, zs))))
                            v := sload(add(rootSlot, n))
                            if v {
                                n := 3
                                mstore(add(o, 0x40), mul(v, iszero(eq(v, zs))))
                            }
                        }
                    }
                    break
                }
                n := shr(1, n)
                for { let i := 0 } lt(i, n) { i := add(i, 1) } {
                    let v := sload(add(rootSlot, i))
                    mstore(add(o, shl(5, i)), mul(v, iszero(eq(v, zs))))
                }
                break
            }
            mstore(result, n)
            mstore(0x40, add(o, shl(5, n)))
        }
    }

    /// @dev Returns all of the values in the set.
    /// Note: This can consume more gas than the block gas limit for large sets.
    function values(Uint256Set storage set) internal view returns (uint256[] memory result) {
        result = _toUints(values(_toBytes32Set(set)));
    }

    /// @dev Returns all of the values in the set.
    /// Note: This can consume more gas than the block gas limit for large sets.
    function values(Int256Set storage set) internal view returns (int256[] memory result) {
        result = _toInts(values(_toBytes32Set(set)));
    }

    /// @dev Returns all of the values in the set.
    function values(Uint8Set storage set) internal view returns (uint8[] memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(0x40)
            let ptr := add(result, 0x20)
            let o := 0
            for { let packed := sload(set.slot) } packed {} {
                if iszero(and(packed, 0xffff)) {
                    o := add(o, 16)
                    packed := shr(16, packed)
                    continue
                }
                mstore(ptr, o)
                ptr := add(ptr, shl(5, and(packed, 1)))
                o := add(o, 1)
                packed := shr(1, packed)
            }
            mstore(result, shr(5, sub(ptr, add(result, 0x20))))
            mstore(0x40, ptr)
        }
    }

    /// @dev Returns the element at index `i` in the set.
    function at(AddressSet storage set, uint256 i) internal view returns (address result) {
        bytes32 rootSlot = _rootSlot(set);
        /// @solidity memory-safe-assembly
        assembly {
            result := shr(96, sload(add(rootSlot, i)))
            result := mul(result, iszero(eq(result, _ZERO_SENTINEL)))
        }
        if (i >= length(set)) revert IndexOutOfBounds();
    }

    /// @dev Returns the element at index `i` in the set.
    function at(Bytes32Set storage set, uint256 i) internal view returns (bytes32 result) {
        result = _rootSlot(set);
        /// @solidity memory-safe-assembly
        assembly {
            result := sload(add(result, i))
            result := mul(result, iszero(eq(result, _ZERO_SENTINEL)))
        }
        if (i >= length(set)) revert IndexOutOfBounds();
    }

    /// @dev Returns the element at index `i` in the set.
    function at(Uint256Set storage set, uint256 i) internal view returns (uint256 result) {
        result = uint256(at(_toBytes32Set(set), i));
    }

    /// @dev Returns the element at index `i` in the set.
    function at(Int256Set storage set, uint256 i) internal view returns (int256 result) {
        result = int256(uint256(at(_toBytes32Set(set), i)));
    }

    /// @dev Returns the element at index `i` in the set.
    function at(Uint8Set storage set, uint256 i) internal view returns (uint8 result) {
        /// @solidity memory-safe-assembly
        assembly {
            let packed := sload(set.slot)
            for {} 1 {
                mstore(0x00, 0x4e23d035) // `IndexOutOfBounds()`.
                revert(0x1c, 0x04)
            } {
                if iszero(lt(i, 256)) { continue }
                for { let j := 0 } iszero(eq(i, j)) {} {
                    packed := xor(packed, and(packed, add(1, not(packed))))
                    j := add(j, 1)
                }
                if iszero(packed) { continue }
                break
            }
            // Find first set subroutine, optimized for smaller bytecode size.
            let x := and(packed, add(1, not(packed)))
            let r := shl(7, iszero(iszero(shr(128, x))))
            r := or(r, shl(6, iszero(iszero(shr(64, shr(r, x))))))
            r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
            // For the lower 5 bits of the result, use a De Bruijn lookup.
            // forgefmt: disable-next-item
            result := or(r, byte(and(div(0xd76453e0, shr(r, x)), 0x1f),
                0x001f0d1e100c1d070f090b19131c1706010e11080a1a141802121b1503160405))
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                      PRIVATE HELPERS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the root slot.
    function _rootSlot(AddressSet storage s) private pure returns (bytes32 r) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x04, _ENUMERABLE_ADDRESS_SET_SLOT_SEED)
            mstore(0x00, s.slot)
            r := keccak256(0x00, 0x24)
        }
    }

    /// @dev Returns the root slot.
    function _rootSlot(Bytes32Set storage s) private pure returns (bytes32 r) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x04, _ENUMERABLE_WORD_SET_SLOT_SEED)
            mstore(0x00, s.slot)
            r := keccak256(0x00, 0x24)
        }
    }

    /// @dev Casts to a Bytes32Set.
    function _toBytes32Set(Uint256Set storage s) private pure returns (Bytes32Set storage c) {
        /// @solidity memory-safe-assembly
        assembly {
            c.slot := s.slot
        }
    }

    /// @dev Casts to a Bytes32Set.
    function _toBytes32Set(Int256Set storage s) private pure returns (Bytes32Set storage c) {
        /// @solidity memory-safe-assembly
        assembly {
            c.slot := s.slot
        }
    }

    /// @dev Casts to a uint256 array.
    function _toUints(bytes32[] memory a) private pure returns (uint256[] memory c) {
        /// @solidity memory-safe-assembly
        assembly {
            c := a
        }
    }

    /// @dev Casts to a int256 array.
    function _toInts(bytes32[] memory a) private pure returns (int256[] memory c) {
        /// @solidity memory-safe-assembly
        assembly {
            c := a
        }
    }
}

// SPDX-License-Identifier: MIT
// ERC721A Contracts v4.3.0
// Creator: Chiru Labs

pragma solidity ^0.8.4;

/**
 * @dev Interface of ERC721A.
 */
interface IERC721A {
    /**
     * The caller must own the token or be an approved operator.
     */
    error ApprovalCallerNotOwnerNorApproved();

    /**
     * The token does not exist.
     */
    error ApprovalQueryForNonexistentToken();

    /**
     * Cannot query the balance for the zero address.
     */
    error BalanceQueryForZeroAddress();

    /**
     * Cannot mint to the zero address.
     */
    error MintToZeroAddress();

    /**
     * The quantity of tokens minted must be more than zero.
     */
    error MintZeroQuantity();

    /**
     * The token does not exist.
     */
    error OwnerQueryForNonexistentToken();

    /**
     * The caller must own the token or be an approved operator.
     */
    error TransferCallerNotOwnerNorApproved();

    /**
     * The token must be owned by `from`.
     */
    error TransferFromIncorrectOwner();

    /**
     * Cannot safely transfer to a contract that does not implement the
     * ERC721Receiver interface.
     */
    error TransferToNonERC721ReceiverImplementer();

    /**
     * Cannot transfer to the zero address.
     */
    error TransferToZeroAddress();

    /**
     * The token does not exist.
     */
    error URIQueryForNonexistentToken();

    /**
     * The `quantity` minted with ERC2309 exceeds the safety limit.
     */
    error MintERC2309QuantityExceedsLimit();

    /**
     * The `extraData` cannot be set on an unintialized ownership slot.
     */
    error OwnershipNotInitializedForExtraData();

    /**
     * `_sequentialUpTo()` must be greater than `_startTokenId()`.
     */
    error SequentialUpToTooSmall();

    /**
     * The `tokenId` of a sequential mint exceeds `_sequentialUpTo()`.
     */
    error SequentialMintExceedsLimit();

    /**
     * Spot minting requires a `tokenId` greater than `_sequentialUpTo()`.
     */
    error SpotMintTokenIdTooSmall();

    /**
     * Cannot mint over a token that already exists.
     */
    error TokenAlreadyExists();

    /**
     * The feature is not compatible with spot mints.
     */
    error NotCompatibleWithSpotMints();

    // =============================================================
    //                            STRUCTS
    // =============================================================

    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Stores the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
        // Arbitrary data similar to `startTimestamp` that can be set via {_extraData}.
        uint24 extraData;
    }

    // =============================================================
    //                         TOKEN COUNTERS
    // =============================================================

    /**
     * @dev Returns the total number of tokens in existence.
     * Burned tokens will reduce the count.
     * To get the total number of tokens minted, please see {_totalMinted}.
     */
    function totalSupply() external view returns (uint256);

    // =============================================================
    //                            IERC165
    // =============================================================

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

    // =============================================================
    //                            IERC721
    // =============================================================

    /**
     * @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`,
     * 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 be 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,
        bytes calldata data
    ) external payable;

    /**
     * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external payable;

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom}
     * whenever possible.
     *
     * 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 payable;

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

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

    // =============================================================
    //                        IERC721Metadata
    // =============================================================

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

    // =============================================================
    //                           IERC2309
    // =============================================================

    /**
     * @dev Emitted when tokens in `fromTokenId` to `toTokenId`
     * (inclusive) is transferred from `from` to `to`, as defined in the
     * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309) standard.
     *
     * See {_mintERC2309} for more details.
     */
    event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Library for bit twiddling and boolean operations.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibBit.sol)
/// @author Inspired by (https://graphics.stanford.edu/~seander/bithacks.html)
library LibBit {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  BIT TWIDDLING OPERATIONS                  */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Find last set.
    /// Returns the index of the most significant bit of `x`,
    /// counting from the least significant bit position.
    /// If `x` is zero, returns 256.
    function fls(uint256 x) internal pure returns (uint256 r) {
        /// @solidity memory-safe-assembly
        assembly {
            r := or(shl(8, iszero(x)), shl(7, lt(0xffffffffffffffffffffffffffffffff, x)))
            r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
            r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
            r := or(r, shl(4, lt(0xffff, shr(r, x))))
            r := or(r, shl(3, lt(0xff, shr(r, x))))
            // forgefmt: disable-next-item
            r := or(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),
                0x0706060506020504060203020504030106050205030304010505030400000000))
        }
    }

    /// @dev Count leading zeros.
    /// Returns the number of zeros preceding the most significant one bit.
    /// If `x` is zero, returns 256.
    function clz(uint256 x) internal pure returns (uint256 r) {
        /// @solidity memory-safe-assembly
        assembly {
            r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
            r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
            r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
            r := or(r, shl(4, lt(0xffff, shr(r, x))))
            r := or(r, shl(3, lt(0xff, shr(r, x))))
            // forgefmt: disable-next-item
            r := add(xor(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),
                0xf8f9f9faf9fdfafbf9fdfcfdfafbfcfef9fafdfafcfcfbfefafafcfbffffffff)), iszero(x))
        }
    }

    /// @dev Find first set.
    /// Returns the index of the least significant bit of `x`,
    /// counting from the least significant bit position.
    /// If `x` is zero, returns 256.
    /// Equivalent to `ctz` (count trailing zeros), which gives
    /// the number of zeros following the least significant one bit.
    function ffs(uint256 x) internal pure returns (uint256 r) {
        /// @solidity memory-safe-assembly
        assembly {
            // Isolate the least significant bit.
            x := and(x, add(not(x), 1))
            // For the upper 3 bits of the result, use a De Bruijn-like lookup.
            // Credit to adhusson: https://blog.adhusson.com/cheap-find-first-set-evm/
            // forgefmt: disable-next-item
            r := shl(5, shr(252, shl(shl(2, shr(250, mul(x,
                0xb6db6db6ddddddddd34d34d349249249210842108c6318c639ce739cffffffff))),
                0x8040405543005266443200005020610674053026020000107506200176117077)))
            // For the lower 5 bits of the result, use a De Bruijn lookup.
            // forgefmt: disable-next-item
            r := or(r, byte(and(div(0xd76453e0, shr(r, x)), 0x1f),
                0x001f0d1e100c1d070f090b19131c1706010e11080a1a141802121b1503160405))
        }
    }

    /// @dev Returns the number of set bits in `x`.
    function popCount(uint256 x) internal pure returns (uint256 c) {
        /// @solidity memory-safe-assembly
        assembly {
            let max := not(0)
            let isMax := eq(x, max)
            x := sub(x, and(shr(1, x), div(max, 3)))
            x := add(and(x, div(max, 5)), and(shr(2, x), div(max, 5)))
            x := and(add(x, shr(4, x)), div(max, 17))
            c := or(shl(8, isMax), shr(248, mul(x, div(max, 255))))
        }
    }

    /// @dev Returns whether `x` is a power of 2.
    function isPo2(uint256 x) internal pure returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            // Equivalent to `x && !(x & (x - 1))`.
            result := iszero(add(and(x, sub(x, 1)), iszero(x)))
        }
    }

    /// @dev Returns `x` reversed at the bit level.
    function reverseBits(uint256 x) internal pure returns (uint256 r) {
        uint256 m0 = 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f;
        uint256 m1 = m0 ^ (m0 << 2);
        uint256 m2 = m1 ^ (m1 << 1);
        r = reverseBytes(x);
        r = (m2 & (r >> 1)) | ((m2 & r) << 1);
        r = (m1 & (r >> 2)) | ((m1 & r) << 2);
        r = (m0 & (r >> 4)) | ((m0 & r) << 4);
    }

    /// @dev Returns `x` reversed at the byte level.
    function reverseBytes(uint256 x) internal pure returns (uint256 r) {
        unchecked {
            // Computing masks on-the-fly reduces bytecode size by about 200 bytes.
            uint256 m0 = 0x100000000000000000000000000000001 * (~toUint(x == uint256(0)) >> 192);
            uint256 m1 = m0 ^ (m0 << 32);
            uint256 m2 = m1 ^ (m1 << 16);
            uint256 m3 = m2 ^ (m2 << 8);
            r = (m3 & (x >> 8)) | ((m3 & x) << 8);
            r = (m2 & (r >> 16)) | ((m2 & r) << 16);
            r = (m1 & (r >> 32)) | ((m1 & r) << 32);
            r = (m0 & (r >> 64)) | ((m0 & r) << 64);
            r = (r >> 128) | (r << 128);
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     BOOLEAN OPERATIONS                     */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    // A Solidity bool on the stack or memory is represented as a 256-bit word.
    // Non-zero values are true, zero is false.
    // A clean bool is either 0 (false) or 1 (true) under the hood.
    // Usually, if not always, the bool result of a regular Solidity expression,
    // or the argument of a public/external function will be a clean bool.
    // You can usually use the raw variants for more performance.
    // If uncertain, test (best with exact compiler settings).
    // Or use the non-raw variants (compiler can sometimes optimize out the double `iszero`s).

    /// @dev Returns `x & y`. Inputs must be clean.
    function rawAnd(bool x, bool y) internal pure returns (bool z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := and(x, y)
        }
    }

    /// @dev Returns `x & y`.
    function and(bool x, bool y) internal pure returns (bool z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := and(iszero(iszero(x)), iszero(iszero(y)))
        }
    }

    /// @dev Returns `x | y`. Inputs must be clean.
    function rawOr(bool x, bool y) internal pure returns (bool z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := or(x, y)
        }
    }

    /// @dev Returns `x | y`.
    function or(bool x, bool y) internal pure returns (bool z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := or(iszero(iszero(x)), iszero(iszero(y)))
        }
    }

    /// @dev Returns 1 if `b` is true, else 0. Input must be clean.
    function rawToUint(bool b) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := b
        }
    }

    /// @dev Returns 1 if `b` is true, else 0.
    function toUint(bool b) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := iszero(iszero(b))
        }
    }
}

{
  "remappings": [
    "forge-std/=node_modules/forge-std/",
    "erc721a/contracts/=node_modules/erc721a/contracts/",
    "solady/src/=node_modules/solady/src/",
    "@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 10000
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "none",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "shanghai",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"_lockTime","type":"uint256"},{"internalType":"bytes32","name":"_provenanceHash","type":"bytes32"},{"internalType":"uint32","name":"_cooldownExpiry","type":"uint32"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"inputs":[],"name":"AlreadySet","type":"error"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintERC2309QuantityExceedsLimit","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[],"name":"NoHandoverRequest","type":"error"},{"inputs":[],"name":"NotCompatibleWithSpotMints","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"OwnershipNotInitializedForExtraData","type":"error"},{"inputs":[],"name":"SequentialMintExceedsLimit","type":"error"},{"inputs":[],"name":"SequentialUpToTooSmall","type":"error"},{"inputs":[],"name":"Snorfliks_CannotAirdrop","type":"error"},{"inputs":[],"name":"Snorfliks_ChunkAlreadyProcessed","type":"error"},{"inputs":[],"name":"Snorfliks_CooldownPeriod","type":"error"},{"inputs":[],"name":"Snorfliks_IdenticalIds","type":"error"},{"inputs":[],"name":"Snorfliks_InsufficientFunds","type":"error"},{"inputs":[],"name":"Snorfliks_InvalidIndex","type":"error"},{"inputs":[],"name":"Snorfliks_InvalidNonce","type":"error"},{"inputs":[],"name":"Snorfliks_InvalidSender","type":"error"},{"inputs":[],"name":"Snorfliks_InvalidTarget","type":"error"},{"inputs":[],"name":"Snorfliks_Locked","type":"error"},{"inputs":[],"name":"Snorfliks_MaxMintedForAddress","type":"error"},{"inputs":[],"name":"Snorfliks_MismatchedArrays","type":"error"},{"inputs":[],"name":"Snorfliks_NonexistentToken","type":"error"},{"inputs":[],"name":"Snorfliks_OnCooldown","type":"error"},{"inputs":[],"name":"Snorfliks_OnlyWithdrawer","type":"error"},{"inputs":[],"name":"Snorfliks_OverMaxSupply","type":"error"},{"inputs":[],"name":"Snorfliks_PurgeNotOn","type":"error"},{"inputs":[],"name":"Snorfliks_PurgeOn","type":"error"},{"inputs":[],"name":"Snorfliks_TargetSafe","type":"error"},{"inputs":[],"name":"Snorfliks_URISet","type":"error"},{"inputs":[],"name":"SpotMintTokenIdTooSmall","type":"error"},{"inputs":[],"name":"TokenAlreadyExists","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"inputs":[],"name":"Zero","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint8","name":"chunkNum","type":"uint8"}],"name":"AirdroppedChunk","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"senderId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"targetId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rank","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Allocate","type":"event"},{"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":"uint256","name":"senderId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"targetId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rank","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claim","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"fromTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"toTokenId","type":"uint256"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"ConsecutiveTransfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"senderId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"targetId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rank","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Donate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"start","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"end","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"cooldownExpiry","type":"uint256"}],"name":"Purge","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"senderId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"targetId","type":"uint256"}],"name":"Purged","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"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rank","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Upgrade","type":"event"},{"inputs":[],"name":"COOLDOWN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DURATION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LOCK_TIME","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_BATCH_SIZE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_PER_ADDRESS_MINT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINT_COST","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PEACE_URI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PROVENANCE_HASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PURGE_URI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UPGRADE_COST","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WITHDRAW_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"receivers","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"uint8","name":"chunkNum","type":"uint8"}],"name":"airdrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"senderId","type":"uint256"},{"internalType":"uint256","name":"targetId","type":"uint256"}],"name":"allocate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cancelOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"senderId","type":"uint256"},{"internalType":"uint256","name":"targetId","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"completeOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"cooldownExpiry","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentNonce","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"senderId","type":"uint256"},{"internalType":"uint256","name":"targetId","type":"uint256"}],"name":"donate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"end","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"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":"getEligibleTokensCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getMaxMintable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getNumMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPhase","outputs":[{"internalType":"enum Snorfliks.Phase","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"attackerId","type":"uint256"},{"internalType":"uint256","name":"targetId","type":"uint256"}],"name":"getPurgeCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"getRanksToAssign","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getTokenInfo","outputs":[{"components":[{"internalType":"bool","name":"exists","type":"bool"},{"internalType":"bool","name":"cooldown","type":"bool"},{"internalType":"bool","name":"safe","type":"bool"},{"internalType":"uint16","name":"rank","type":"uint16"},{"internalType":"uint16","name":"receiveLimit","type":"uint16"},{"internalType":"uint16","name":"ranksToAssign","type":"uint16"}],"internalType":"struct DataTypes.TokenInfo","name":"","type":"tuple"}],"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":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"isAuthorizedForToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint8","name":"amount","type":"uint8"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"result","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":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"ownershipHandoverExpiresAt","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"receivers","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"privilegedMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"senderId","type":"uint256"},{"internalType":"uint256","name":"targetId","type":"uint256"}],"name":"purge","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"requestOwnershipHandover","outputs":[],"stateMutability":"payable","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":"payable","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":"payable","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":"peaceURI","type":"string"},{"internalType":"string","name":"purgeURI","type":"string"}],"name":"setURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"withdrawAddress","type":"address"}],"name":"setWithdrawAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"start","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startPurge","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":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"result","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":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"upgrade","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000000000000000000000000000000000000068484870837e90279f0bad780c943ee04652f32318004f4a01f648a96099d749095a4e6a0000000000000000000000000000000000000000000000000000000067f68b70

-----Decoded View---------------
Arg [0] : _lockTime (uint256): 1749567600
Arg [1] : _provenanceHash (bytes32): 0x837e90279f0bad780c943ee04652f32318004f4a01f648a96099d749095a4e6a
Arg [2] : _cooldownExpiry (uint32): 1744210800

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000068484870
Arg [1] : 837e90279f0bad780c943ee04652f32318004f4a01f648a96099d749095a4e6a
Arg [2] : 0000000000000000000000000000000000000000000000000000000067f68b70