Datasets:

UTSCybeR
/

nftbench

// SPDX-License-Identifier: MIT
/**
   _____       ___     ___ __           ____  _ __      
  / ___/____  / (_)___/ (_) /___  __   / __ )(_) /______
  \__ \/ __ \/ / / __  / / __/ / / /  / __  / / __/ ___/
 ___/ / /_/ / / / /_/ / / /_/ /_/ /  / /_/ / / /_(__  ) 
/____/\____/_/_/\__,_/_/\__/\__, /  /_____/_/\__/____/  
                           /____/                        
- npm: https://www.npmjs.com/package/solidity-bits
- github: https://github.com/estarriolvetch/solidity-bits
 */
pragma solidity ^0.8.0;

import "./BitScan.sol";
import "./Popcount.sol";

/**
 * @dev This Library is a modified version of Openzeppelin's BitMaps library with extra features.
 *
 * 1. Functions of finding the index of the closest set bit from a given index are added.
 *    The indexing of each bucket is modifed to count from the MSB to the LSB instead of from the LSB to the MSB.
 *    The modification of indexing makes finding the closest previous set bit more efficient in gas usage.
 * 2. Setting and unsetting the bitmap consecutively.
 * 3. Accounting number of set bits within a given range.   
 *
*/

/**
 * @dev Library for managing uint256 to bool mapping in a compact and efficient way, providing the keys are sequential.
 * Largelly inspired by Uniswap's https://github.com/Uniswap/merkle-distributor/blob/master/contracts/MerkleDistributor.sol[merkle-distributor].
 */

library BitMaps {
    using BitScan for uint256;
    uint256 private constant MASK_INDEX_ZERO = (1 << 255);
    uint256 private constant MASK_FULL = type(uint256).max;

    struct BitMap {
        mapping(uint256 => uint256) _data;
    }

    /**
     * @dev Returns whether the bit at `index` is set.
     */
    function get(BitMap storage bitmap, uint256 index) internal view returns (bool) {
        uint256 bucket = index >> 8;
        uint256 mask = MASK_INDEX_ZERO >> (index & 0xff);
        return bitmap._data[bucket] & mask != 0;
    }

    /**
     * @dev Sets the bit at `index` to the boolean `value`.
     */
    function setTo(
        BitMap storage bitmap,
        uint256 index,
        bool value
    ) internal {
        if (value) {
            set(bitmap, index);
        } else {
            unset(bitmap, index);
        }
    }

    /**
     * @dev Sets the bit at `index`.
     */
    function set(BitMap storage bitmap, uint256 index) internal {
        uint256 bucket = index >> 8;
        uint256 mask = MASK_INDEX_ZERO >> (index & 0xff);
        bitmap._data[bucket] |= mask;
    }

    /**
     * @dev Unsets the bit at `index`.
     */
    function unset(BitMap storage bitmap, uint256 index) internal {
        uint256 bucket = index >> 8;
        uint256 mask = MASK_INDEX_ZERO >> (index & 0xff);
        bitmap._data[bucket] &= ~mask;
    }


    /**
     * @dev Consecutively sets `amount` of bits starting from the bit at `startIndex`.
     */    
    function setBatch(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal {
        uint256 bucket = startIndex >> 8;

        uint256 bucketStartIndex = (startIndex & 0xff);

        unchecked {
            if(bucketStartIndex + amount < 256) {
                bitmap._data[bucket] |= MASK_FULL << (256 - amount) >> bucketStartIndex;
            } else {
                bitmap._data[bucket] |= MASK_FULL >> bucketStartIndex;
                amount -= (256 - bucketStartIndex);
                bucket++;

                while(amount > 256) {
                    bitmap._data[bucket] = MASK_FULL;
                    amount -= 256;
                    bucket++;
                }

                bitmap._data[bucket] |= MASK_FULL << (256 - amount);
            }
        }
    }


    /**
     * @dev Consecutively unsets `amount` of bits starting from the bit at `startIndex`.
     */    
    function unsetBatch(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal {
        uint256 bucket = startIndex >> 8;

        uint256 bucketStartIndex = (startIndex & 0xff);

        unchecked {
            if(bucketStartIndex + amount < 256) {
                bitmap._data[bucket] &= ~(MASK_FULL << (256 - amount) >> bucketStartIndex);
            } else {
                bitmap._data[bucket] &= ~(MASK_FULL >> bucketStartIndex);
                amount -= (256 - bucketStartIndex);
                bucket++;

                while(amount > 256) {
                    bitmap._data[bucket] = 0;
                    amount -= 256;
                    bucket++;
                }

                bitmap._data[bucket] &= ~(MASK_FULL << (256 - amount));
            }
        }
    }

    /**
     * @dev Returns number of set bits within a range.
     */
    function popcountA(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal view returns(uint256 count) {
        uint256 bucket = startIndex >> 8;

        uint256 bucketStartIndex = (startIndex & 0xff);

        unchecked {
            if(bucketStartIndex + amount < 256) {
                count +=  Popcount.popcount256A(
                    bitmap._data[bucket] & (MASK_FULL << (256 - amount) >> bucketStartIndex)
                );
            } else {
                count += Popcount.popcount256A(
                    bitmap._data[bucket] & (MASK_FULL >> bucketStartIndex)
                );
                amount -= (256 - bucketStartIndex);
                bucket++;

                while(amount > 256) {
                    count += Popcount.popcount256A(bitmap._data[bucket]);
                    amount -= 256;
                    bucket++;
                }
                count += Popcount.popcount256A(
                    bitmap._data[bucket] & (MASK_FULL << (256 - amount))
                );
            }
        }
    }

    /**
     * @dev Returns number of set bits within a range.
     */
    function popcountB(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal view returns(uint256 count) {
        uint256 bucket = startIndex >> 8;

        uint256 bucketStartIndex = (startIndex & 0xff);

        unchecked {
            if(bucketStartIndex + amount < 256) {
                count +=  Popcount.popcount256B(
                    bitmap._data[bucket] & (MASK_FULL << (256 - amount) >> bucketStartIndex)
                );
            } else {
                count += Popcount.popcount256B(
                    bitmap._data[bucket] & (MASK_FULL >> bucketStartIndex)
                );
                amount -= (256 - bucketStartIndex);
                bucket++;

                while(amount > 256) {
                    count += Popcount.popcount256B(bitmap._data[bucket]);
                    amount -= 256;
                    bucket++;
                }
                count += Popcount.popcount256B(
                    bitmap._data[bucket] & (MASK_FULL << (256 - amount))
                );
            }
        }
    }


    /**
     * @dev Find the closest index of the set bit before `index`.
     */
    function scanForward(BitMap storage bitmap, uint256 index) internal view returns (uint256 setBitIndex) {
        uint256 bucket = index >> 8;

        // index within the bucket
        uint256 bucketIndex = (index & 0xff);

        // load a bitboard from the bitmap.
        uint256 bb = bitmap._data[bucket];

        // offset the bitboard to scan from `bucketIndex`.
        bb = bb >> (0xff ^ bucketIndex); // bb >> (255 - bucketIndex)
        
        if(bb > 0) {
            unchecked {
                setBitIndex = (bucket << 8) | (bucketIndex -  bb.bitScanForward256());    
            }
        } else {
            while(true) {
                require(bucket > 0, "BitMaps: The set bit before the index doesn't exist.");
                unchecked {
                    bucket--;
                }
                // No offset. Always scan from the least significiant bit now.
                bb = bitmap._data[bucket];
                
                if(bb > 0) {
                    unchecked {
                        setBitIndex = (bucket << 8) | (255 -  bb.bitScanForward256());
                        break;
                    }
                } 
            }
        }
    }

    function getBucket(BitMap storage bitmap, uint256 bucket) internal view returns (uint256) {
        return bitmap._data[bucket];
    }
}

	// SPDX-License-Identifier: MIT
	/**
	_____ ___ ___ __ ____ _ __
	/ ___/____ / (_)___/ (_) /___ __ / __ )(_) /______
	\__ \/ __ \/ / / __ / / __/ / / / / __ / / __/ ___/
	___/ / /_/ / / / /_/ / / /_/ /_/ / / /_/ / / /_(__ )
	/____/\____/_/_/\__,_/_/\__/\__, / /_____/_/\__/____/
	/____/

	- npm: https://www.npmjs.com/package/solidity-bits
	- github: https://github.com/estarriolvetch/solidity-bits

	*/
	pragma solidity ^0.8.0;

	import "./BitScan.sol";
	import "./Popcount.sol";

	/**
	* @dev This Library is a modified version of Openzeppelin's BitMaps library with extra features.
	*
	* 1. Functions of finding the index of the closest set bit from a given index are added.
	* The indexing of each bucket is modifed to count from the MSB to the LSB instead of from the LSB to the MSB.
	* The modification of indexing makes finding the closest previous set bit more efficient in gas usage.
	* 2. Setting and unsetting the bitmap consecutively.
	* 3. Accounting number of set bits within a given range.
	*
	*/

	/**
	* @dev Library for managing uint256 to bool mapping in a compact and efficient way, providing the keys are sequential.
	* Largelly inspired by Uniswap's https://github.com/Uniswap/merkle-distributor/blob/master/contracts/MerkleDistributor.sol[merkle-distributor].
	*/

	library BitMaps {
	using BitScan for uint256;
	uint256 private constant MASK_INDEX_ZERO = (1 << 255);
	uint256 private constant MASK_FULL = type(uint256).max;

	struct BitMap {
	mapping(uint256 => uint256) _data;
	}

	/**
	* @dev Returns whether the bit at `index` is set.
	*/
	function get(BitMap storage bitmap, uint256 index) internal view returns (bool) {
	uint256 bucket = index >> 8;
	uint256 mask = MASK_INDEX_ZERO >> (index & 0xff);
	return bitmap._data[bucket] & mask != 0;
	}

	/**
	* @dev Sets the bit at `index` to the boolean `value`.
	*/
	function setTo(
	BitMap storage bitmap,
	uint256 index,
	bool value
	) internal {
	if (value) {
	set(bitmap, index);
	} else {
	unset(bitmap, index);
	}
	}

	/**
	* @dev Sets the bit at `index`.
	*/
	function set(BitMap storage bitmap, uint256 index) internal {
	uint256 bucket = index >> 8;
	uint256 mask = MASK_INDEX_ZERO >> (index & 0xff);
	bitmap._data[bucket] \|= mask;
	}

	/**
	* @dev Unsets the bit at `index`.
	*/
	function unset(BitMap storage bitmap, uint256 index) internal {
	uint256 bucket = index >> 8;
	uint256 mask = MASK_INDEX_ZERO >> (index & 0xff);
	bitmap._data[bucket] &= ~mask;
	}


	/**
	* @dev Consecutively sets `amount` of bits starting from the bit at `startIndex`.
	*/
	function setBatch(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal {
	uint256 bucket = startIndex >> 8;

	uint256 bucketStartIndex = (startIndex & 0xff);

	unchecked {
	if(bucketStartIndex + amount < 256) {
	bitmap._data[bucket] \|= MASK_FULL << (256 - amount) >> bucketStartIndex;
	} else {
	bitmap._data[bucket] \|= MASK_FULL >> bucketStartIndex;
	amount -= (256 - bucketStartIndex);
	bucket++;

	while(amount > 256) {
	bitmap._data[bucket] = MASK_FULL;
	amount -= 256;
	bucket++;
	}

	bitmap._data[bucket] \|= MASK_FULL << (256 - amount);
	}
	}
	}


	/**
	* @dev Consecutively unsets `amount` of bits starting from the bit at `startIndex`.
	*/
	function unsetBatch(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal {
	uint256 bucket = startIndex >> 8;

	uint256 bucketStartIndex = (startIndex & 0xff);

	unchecked {
	if(bucketStartIndex + amount < 256) {
	bitmap._data[bucket] &= ~(MASK_FULL << (256 - amount) >> bucketStartIndex);
	} else {
	bitmap._data[bucket] &= ~(MASK_FULL >> bucketStartIndex);
	amount -= (256 - bucketStartIndex);
	bucket++;

	while(amount > 256) {
	bitmap._data[bucket] = 0;
	amount -= 256;
	bucket++;
	}

	bitmap._data[bucket] &= ~(MASK_FULL << (256 - amount));
	}
	}
	}

	/**
	* @dev Returns number of set bits within a range.
	*/
	function popcountA(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal view returns(uint256 count) {
	uint256 bucket = startIndex >> 8;

	uint256 bucketStartIndex = (startIndex & 0xff);

	unchecked {
	if(bucketStartIndex + amount < 256) {
	count += Popcount.popcount256A(
	bitmap._data[bucket] & (MASK_FULL << (256 - amount) >> bucketStartIndex)
	);
	} else {
	count += Popcount.popcount256A(
	bitmap._data[bucket] & (MASK_FULL >> bucketStartIndex)
	);
	amount -= (256 - bucketStartIndex);
	bucket++;

	while(amount > 256) {
	count += Popcount.popcount256A(bitmap._data[bucket]);
	amount -= 256;
	bucket++;
	}
	count += Popcount.popcount256A(
	bitmap._data[bucket] & (MASK_FULL << (256 - amount))
	);
	}
	}
	}

	/**
	* @dev Returns number of set bits within a range.
	*/
	function popcountB(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal view returns(uint256 count) {
	uint256 bucket = startIndex >> 8;

	uint256 bucketStartIndex = (startIndex & 0xff);

	unchecked {
	if(bucketStartIndex + amount < 256) {
	count += Popcount.popcount256B(
	bitmap._data[bucket] & (MASK_FULL << (256 - amount) >> bucketStartIndex)
	);
	} else {
	count += Popcount.popcount256B(
	bitmap._data[bucket] & (MASK_FULL >> bucketStartIndex)
	);
	amount -= (256 - bucketStartIndex);
	bucket++;

	while(amount > 256) {
	count += Popcount.popcount256B(bitmap._data[bucket]);
	amount -= 256;
	bucket++;
	}
	count += Popcount.popcount256B(
	bitmap._data[bucket] & (MASK_FULL << (256 - amount))
	);
	}
	}
	}


	/**
	* @dev Find the closest index of the set bit before `index`.
	*/
	function scanForward(BitMap storage bitmap, uint256 index) internal view returns (uint256 setBitIndex) {
	uint256 bucket = index >> 8;

	// index within the bucket
	uint256 bucketIndex = (index & 0xff);

	// load a bitboard from the bitmap.
	uint256 bb = bitmap._data[bucket];

	// offset the bitboard to scan from `bucketIndex`.
	bb = bb >> (0xff ^ bucketIndex); // bb >> (255 - bucketIndex)

	if(bb > 0) {
	unchecked {
	setBitIndex = (bucket << 8) \| (bucketIndex - bb.bitScanForward256());
	}
	} else {
	while(true) {
	require(bucket > 0, "BitMaps: The set bit before the index doesn't exist.");
	unchecked {
	bucket--;
	}
	// No offset. Always scan from the least significiant bit now.
	bb = bitmap._data[bucket];

	if(bb > 0) {
	unchecked {
	setBitIndex = (bucket << 8) \| (255 - bb.bitScanForward256());
	break;
	}
	}
	}
	}
	}

	function getBucket(BitMap storage bitmap, uint256 bucket) internal view returns (uint256) {
	return bitmap._data[bucket];
	}
	}