DN404Storage storage $ = _getDN404Storage();

    t.nextTokenId = _wrapNFTId($.nextTokenId, maxId);
    // Mint loop.
    do {
        uint256 id;
        if (burnedPoolHead != t.burnedPoolTail) {
            id = _get($.burnedPool, burnedPoolHead++);
        } else {
            id = t.nextTokenId;
            while (_get(oo, _ownershipIndex(id)) != 0) {
                id = _useExistsLookup()
                    ? _wrapNFTId(_findFirstUnset($.exists, id + 1, maxId + 1), maxId)
                    : _wrapNFTId(id + 1, maxId);
            }
            t.nextTokenId = _wrapNFTId(id + 1, maxId);
        }
        if (_useExistsLookup()) _set($.exists, id, true);
        _set(toOwned, toIndex, uint32(id));
        _setOwnerAliasAndOwnedIndex(oo, id, t.toAlias, uint32(toIndex++));
        _packedLogsAppend(packedLogs, id);
        _afterNFTTransfer(address(0), to, id);
    } while (toIndex != t.toEnd);

    $.nextTokenId = uint32(t.nextTokenId);

/// @dev Struct containing the base token contract storage.
struct DN404Storage {
    // Current number of address aliases assigned.
    uint32 numAliases;
    // Next NFT ID to assign for a mint.
    uint32 nextTokenId;
    // The head of the burned pool.
    uint32 burnedPoolHead;
    // The tail of the burned pool.
    uint32 burnedPoolTail;
    // Total number of NFTs in existence.
    uint32 totalNFTSupply;
    // Total supply of tokens.
    uint96 totalSupply;
    // Address of the NFT mirror contract.
    address mirrorERC721;
    // Mapping of a user alias number to their address.
    mapping(uint32 => address) aliasToAddress;
    // Mapping of user operator approvals for NFTs.
    AddressPairToUint256RefMap operatorApprovals;
    // Mapping of NFT approvals to approved operators.
    mapping(uint256 => address) nftApprovals;
    // Bitmap of whether an non-zero NFT approval may exist.
    Bitmap mayHaveNFTApproval;
    // Bitmap of whether a NFT ID exists. Ignored if `_useExistsLookup()` returns false.
    Bitmap exists;
    // Mapping of user allowances for ERC20 spenders.
    AddressPairToUint256RefMap allowance;
    // Mapping of NFT IDs owned by an address.
    mapping(address => Uint32Map) owned;
    // The pool of burned NFT IDs.
    Uint32Map burnedPool;
    // Even indices: owner aliases. Odd indices: owned indices.
    Uint32Map oo;
    // Mapping of user account AddressData.
    mapping(address => AddressData) addressData;
}

// Current number of address aliases assigned.
uint32 numAliases;
// Next NFT ID to assign for a mint.
uint32 nextTokenId;
// The head of the burned pool.
uint32 burnedPoolHead;
// The tail of the burned pool.
uint32 burnedPoolTail;
// Total number of NFTs in existence.
uint32 totalNFTSupply;
// Total supply of tokens.
uint96 totalSupply;

let hexString = await provider.getStorage(XTREMEVERSE_ERC20_ADDRESS, '0x0000000000000000000000000000000000000000000000a20d6e21d0e5255308')
// hexString = 0x000000a2a15d09519be0000000000afe00000000000000000000015d000005be

let hexString = await provider.getStorage(XTREMEVERSE_ERC20_ADDRESS, '0x0000000000000000000000000000000000000000000000a20d6e21d0e5255308')
// hexString = 0x000000a2a15d09519be0000000000afe00000000000000000000015d000005be

hexString = hexString.slice(2);

// decode according to how variables are packed in the struct

// first 12 bytes in data hex are totalSupply (uint96 in our solidity struct)
// we take first 24 characters as 2 hex characters represent 1 byte and we are looking for 12 bytes total for totalSupply
const totalSupply = decodeUint('0x' + hexString.slice(0, 24));
// next 4 bytes for totalNFTSupply and so on..
const totalNFTSupply = decodeUint('0x' + hexString.slice(24, 32));
const burnedPoolTail = decodeUint('0x' + hexString.slice(32, 40));
const burnedPoolHead = decodeUint('0x' + hexString.slice(40, 48));
const nextTokenId = decodeUint('0x' + hexString.slice(48, 56));
const numAliases = decodeUint('0x' + hexString.slice(56, 64));

function decodeUint(hex) {
    const value = BigInt(hex);
    return value.toString();
}

function logExistsSlotAddress(uint256 index) public view {
    DN404Storage storage $ = _getDN404Storage();
    Bitmap storage exists = $.exists;
    bytes32 slot = _returnSlot(exists, index);
    console.logBytes32(slot);
}

function _returnSlot(Bitmap storage bitmap, uint256 index) pure internal returns (bytes32 slot) {
    assembly {
        slot := add(shl(96, bitmap.slot), shr(8, index))
    }
}

function getTokenIdBucketSlot(bucket) {
    let existsStructSlot = '0x0000000000000000000000a20d6e21d0e525530e000000000000000000000000'
    // bucket (int) 0,1,2 etc
    let bucketHex = bucket.toString(16)
    let end = existsStructSlot.length - bucketHex.length
    let bucketSlot = existsStructSlot.slice(0, end).concat(bucketHex)
    return bucketSlot
}

let bucketsCount = MAX_TOKEN_ID / 256
let batchCalls = []
for (let i = 0; i < bucketsCount; i++) {
    let bucketSlot = getTokenIdBucketSlot(i)
    batchCalls.push(provider.getStorage(XTREMEVERSE_ERC20_ADDRESS, bucketSlot))
}

const results = await Promise.all(batchCalls);
// results is array of slot data values of each exists bucket

function getTokenIdExists(tokenId) {
    // which bucket this tokenId lies in
    let bucket = Math.floor(tokenId / 256)
    // which bit we need to check for this tokenId
    let bit = tokenId % 256
    // uint256 data value at this bucket (fetched above, different for different bucker)
    let bucketValueHex = '0xfffffffffffffffffffefffffffffffff0207ffbffffffffffffffffffffffff'
    let exists = (BigInt(bucketValueHex) >> BigInt(bit)) & BigInt(1)
    return exists === BigInt(1)
}

let nextNftMints = []
for (let i = parseInt(nextTokenId); i <= MAX_TOKEN_ID; i++) {
    if (!getTokenIdExists(i)) {
        nextNftMints.push(i)
    }
}