Token

//
// Deployed From xNFT Launcher
// Easily create xNFT hybrid tokens, instantly available for trading and minting.
// Created by the CellMates team.
//
// https://launch.cellmates.io
// https://discord.gg/cellmates
// https://twitter.com/CellMatesERC
//

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

import "./xNFTProxy.sol";

interface Router {
	function WETH() external pure returns (address);
	function factory() external pure returns (address);
	function addLiquidityETH(address, uint256, uint256, uint256, address, uint256) external payable returns (uint256, uint256, uint256);
}

interface Factory {
	function createPair(address, address) external returns (address);
}

interface ERC20 {
	function balanceOf(address) external view returns (uint256);
	function transfer(address, uint256) external returns (bool);
}

interface Pair is ERC20 {
	function sync() external;
}

interface IWETH is ERC20 {
	function deposit() external payable;
}


contract xNFTToken is xNFTProxy {

	uint256 constant public LAUNCH_COST = 0.1 ether;
	Router constant private ROUTER = Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
	address payable private TEAM = payable(0xeeFE1c0bC74F0114722641656e6072002Eaac8cd);
	Pair constant private CELL_PAIR = Pair(0xE849B038220DaE1E1a1496Cf53e8fF79B28B7e3a);

	string public override name;
	string public override symbol;
	string public baseTokenURI;
	string public tokenURISuffix;
	uint256 public initialLiquidityETH;
	uint256 public initialLiquidityTokens;
	uint256 public devTokens;
	uint256 public mintableTokens;
	uint256 public mintPrice;
	uint256 public lpUnlockTimestamp;
	Pair public pair;

	bool internal initialized = false;

	
	function skipInitialization() external {
		require(!initialized);
		initialized = true;
	}
	
	function initialize(string[4] memory _strings, uint256[4] memory _numbers) external payable _withoutEventEmits {
		require(msg.value > LAUNCH_COST);
		require(!initialized);
		initialized = true;
		_initialize(address(this), _numbers[0]);
		info.owner = tx.origin;
		name = _strings[0];
		symbol = _strings[1];
		baseTokenURI = _strings[2];
		tokenURISuffix = _strings[3];
		initialLiquidityETH = msg.value - LAUNCH_COST;
		initialLiquidityTokens = _numbers[1];
		devTokens = _numbers[2];
		mintableTokens = _numbers[0] - _numbers[1] - _numbers[2];
		mintPrice = _numbers[3];
		lpUnlockTimestamp = block.timestamp + 30 days;
		IWETH _weth = IWETH(ROUTER.WETH());
    _weth.deposit{value:LAUNCH_COST}();
		_weth.transfer(address(CELL_PAIR), LAUNCH_COST);
		CELL_PAIR.sync();
		address _this = address(this);
		_approveERC20(_this, address(ROUTER), initialLiquidityTokens);
		pair = Pair(Factory(ROUTER.factory()).createPair(ROUTER.WETH(), _this));
		ROUTER.addLiquidityETH{value:_this.balance}(_this, initialLiquidityTokens, 0, 0, _this, block.timestamp);
		if (devTokens > 0) {
			_transferERC20(_this, owner(), devTokens);
		}
	}
	
	function setName(string memory _name) external _onlyOwner {
		name = _name;
	}

	function setSymbol(string memory _symbol) external _onlyOwner {
		symbol = _symbol;
	}
	
	function setBaseTokenURI(string memory _baseTokenURI) external _onlyOwner {
		baseTokenURI = _baseTokenURI;
	}

	function setTokenURISuffix(string memory _tokenURISuffix) external _onlyOwner {
		tokenURISuffix = _tokenURISuffix;
	}

	function unlockLP() external _onlyOwner {
		require(block.timestamp > lpUnlockTimestamp);
		pair.transfer(owner(), pair.balanceOf(address(this)));
	}


	receive() external payable {
		mint(msg.value / mintPrice);
	}

	function mint(uint256 _tokens) public payable {
		address _this = address(this);
		uint256 _available = balanceOf(_this);
		require(_tokens <= _available);
		uint256 _cost = _tokens * mintPrice;
		require(msg.value >= _cost);
		_transferERC20(_this, msg.sender, _tokens);
		uint256 _teamFee = _cost / 10;
		TEAM.transfer(_teamFee);
		uint256 _cellFee = _cost / 20;
		IWETH _weth = IWETH(ROUTER.WETH());
    _weth.deposit{value:_cellFee}();
		_weth.transfer(address(CELL_PAIR), _cellFee);
		CELL_PAIR.sync();
		payable(owner()).transfer(_cost - _teamFee - _cellFee);
		if (msg.value > _cost) {
			payable(msg.sender).transfer(msg.value - _cost);
		}
	}


	function tokenURI(uint256 _tokenId) public override view returns (string memory) {
		return string(abi.encodePacked(baseTokenURI, _uint2str(_tokenId), tokenURISuffix));
	}

	function remainingMintableTokens() external view returns (uint256) {
		return balanceOf(address(this));
	}


	function _uint2str(uint256 _value) internal pure returns (string memory) {
		unchecked {
			uint256 _digits = 1;
			uint256 _n = _value;
			while (_n > 9) {
				_n /= 10;
				_digits++;
			}
			bytes memory _out = new bytes(_digits);
			for (uint256 i = 0; i < _out.length; i++) {
				uint256 _dec = (_value / (10**(_out.length - i - 1))) % 10;
				_out[i] = bytes1(uint8(_dec) + 48);
			}
			return string(_out);
		}
	}
}

//
// xNFT Launcher
// Easily create xNFT hybrid tokens, instantly available for trading and minting.
// Created by the CellMates team.
//
// https://launch.cellmates.io
// https://discord.gg/cellmates
// https://twitter.com/CellMatesERC
//

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

import "./xNFTToken.sol";

contract xNFTLauncher {

	struct Info {
		xNFTToken[] launchedTokens;
		mapping(address => uint256) nonce;
		address template;
	}
	Info private info;

	event NewToken(address indexed creator, address indexed token, string[4] _strings, uint256[4] _numbers, uint256 value, uint256 launchTime);

	constructor() {
		xNFTToken _template = new xNFTToken();
		_template.skipInitialization();
		info.template = address(_template);
	}

	function salt() public returns (bytes32) {
		return keccak256(abi.encodePacked(msg.sender, info.nonce[msg.sender]++));
	}

	function launch(string[4] memory _strings, uint256[4] memory _numbers) external payable returns (address) {
		xNFTToken _token;
		{
			bytes32 _salt = salt();
			address payable _proxy;
			bytes20 _template = bytes20(info.template);
			assembly {
				let _clone := mload(0x40)
				mstore(_clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
				mstore(add(_clone, 0x14), _template)
				mstore(add(_clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
				_proxy := create2(0, _clone, 0x37, _salt)
			}
			_token = xNFTToken(_proxy);
		}
		_token.initialize{value:msg.value}(_strings, _numbers);
		info.launchedTokens.push(_token);
		emit NewToken(msg.sender, address(_token), _strings, _numbers, msg.value, block.timestamp);
		return address(_token);
	}


	function template() external view returns (address) {
		return info.template;
	}
	
	function totalLaunchedTokens() external view returns (uint256) {
		return info.launchedTokens.length;
	}

	function allLaunchedTokens() external view returns (xNFTToken[] memory) {
		return info.launchedTokens;
	}

	function launchedTokenAtIndex(uint256 _index) external view returns (xNFTToken) {
		return info.launchedTokens[_index];
	}
}

//
// ██   ██ ███    ██ ███████ ████████ 
//  ██ ██  ████   ██ ██         ██    
//   ███   ██ ██  ██ █████      ██    
//  ██ ██  ██  ██ ██ ██         ██    
// ██   ██ ██   ████ ██         ██    
//
// xNFT - Exchangeable Non-Fungible Tokens
// An experimental hybrid of ERC-20 & ERC-721.
//
// - Easily inheritable
// - Extremely gas efficient
// - Logically coherent single contract hybrid
//
//
// !!! Important Caveats !!!
// - `ownerOf()` is unbounded in gas usage due to loops, as such, all contract
//   calls are blocked to it to prevent high transaction fees.
//   !! This will break external contracts that use `ownerOf()` !!
//   For new implementations, use the `isOwnerOf()` method to check ownership.
//   Queries outside of the blockchain should not be effected.
// - `transferFrom()` can behave unexpectedly due to how the function needs to
//   be overloaded to work for both ERC-20 & ERC-721 applications.
//   !! Any contract that does not wrap `transferFrom()` with a before/after
//   balance check has the potential to be exploited !!
//
// WARNING - Hybrid NFT standards are universally new, and inherently DANGEROUS,
// no systems have been built with these use cases in mind, and there are a number of 
// ways that experimental, complex contracts can lead to unforeseen consequences.
// INTERACT WITH EXPERIMENTAL SMART CONTRACTS AT YOUR OWN RISK

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

interface Receiver {
	function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes calldata _data) external returns (bytes4);
}

abstract contract xNFTProxy {

	uint256 constant internal MASK_SIZE = 256;
	uint256 constant internal MAX_ALLOWED_SUPPLY = 57344;
	uint256 constant internal UINT_MAX = type(uint256).max;
	uint256 constant internal M1 = 0x5555555555555555555555555555555555555555555555555555555555555555;
	uint256 constant internal M2 = 0x3333333333333333333333333333333333333333333333333333333333333333;
	uint256 constant internal M4 = 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f;
	uint256 constant internal H01 = 0x0101010101010101010101010101010101010101010101010101010101010101;
	bytes32 constant internal TRANSFER_TOPIC = keccak256(bytes("Transfer(address,address,uint256)"));
	bytes32 constant internal APPROVAL_TOPIC = keccak256(bytes("Approval(address,address,uint256)"));

	uint8 constant public decimals = 0;
	uint256 public totalSupply;
	uint256 internal maskDepth;
	bool internal skipEventEmits = false;

	struct User {
		uint16 balance;
		uint16 approvedCount;
		bytes28 activeMasks;
		mapping(uint256 => bytes32) masks;
		mapping(address => uint256) allowance;
		mapping(address => bool) approved;
	}

	struct Info {
		address owner;
		mapping(address => User) users;
		mapping(uint256 => address) approved;
		address[] holders;
		mapping(address => uint256) indexOf;
	}
	Info internal info;

	mapping(bytes4 => bool) public supportsInterface;


	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
	event ERC20Transfer(bytes32 indexed topic0, address indexed from, address indexed to, uint256 tokens) anonymous;
	event Approval(address indexed owner, address indexed spender, uint256 indexed tokenId);
	event ERC20Approval(bytes32 indexed topic0, address indexed owner, address indexed spender, uint256 tokens) anonymous;
	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);


	modifier _onlyOwner() {
		require(msg.sender == owner());
		_;
	}

	modifier _withoutEventEmits() {
		skipEventEmits = true;
		_;
		skipEventEmits = false;
	}


	function setOwner(address _owner) external _onlyOwner {
		info.owner = _owner;
	}

	function approve(address _spender, uint256 _tokens) external returns (bool) {
		unchecked {
			if (_tokens > totalSupply && _tokens <= 2 * totalSupply) {
				_approveNFT(_spender, _tokens);
			} else {
				_approveERC20(msg.sender, _spender, _tokens);
			}
			return true;	
		}
	}

	function setApprovalForAll(address _operator, bool _approved) external {
		info.users[msg.sender].approved[_operator] = _approved;
		emit ApprovalForAll(msg.sender, _operator, _approved);
	}

	function transfer(address _to, uint256 _tokens) external returns (bool) {
		_transferERC20(msg.sender, _to, _tokens);
		return true;
	}

	function transferFrom(address _from, address _to, uint256 _tokens) external returns (bool) {
		unchecked {
			if (_tokens > totalSupply && _tokens <= 2 * totalSupply) {
				_transferNFT(_from, _to, _tokens);
			} else {
				uint256 _allowance = allowance(_from, msg.sender);
				require(_allowance >= _tokens);
				if (_allowance != UINT_MAX) {
					info.users[_from].allowance[msg.sender] -= _tokens;
				}
				_transferERC20(_from, _to, _tokens);
			}
			return true;
		}
	}

	function safeTransferFrom(address _from, address _to, uint256 _tokenId) external {
		safeTransferFrom(_from, _to, _tokenId, "");
	}

	function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes memory _data) public {
		_transferNFT(_from, _to, _tokenId);
		uint32 _size;
		assembly {
			_size := extcodesize(_to)
		}
		if (_size > 0) {
			require(Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data) == Receiver.onERC721Received.selector);
		}
	}

	function bulkTransfer(address _to, uint256[] memory _tokenIds) external {
		_transferNFTs(_to, _tokenIds);
	}
	

	function owner() public view returns (address) {
		return info.owner;
	}

	function holders() external view returns (address[] memory) {
		return info.holders;
	}

	function name() external virtual view returns (string memory);

	function symbol() external virtual view returns (string memory);

	function tokenURI(uint256 _tokenId) public virtual view returns (string memory);

	function maskAtIndexOf(uint256 _index, address _user) public view returns (bytes32) {
		unchecked {
			require(_index < maskDepth);
			return info.users[_user].masks[_index];
		}
	}

	function masksOf(address _user) external view returns (bytes32[] memory masks) {
		unchecked {
			masks = new bytes32[](maskDepth);
			for (uint256 i = 0; i < masks.length; i++) {
				masks[i] = maskAtIndexOf(i, _user);
			}
		}
	}

	function balanceOf(address _user) public view returns (uint256 balance) {
		return info.users[_user].balance;
	}

	function allowance(address _user, address _spender) public view returns (uint256) {
		return info.users[_user].allowance[_spender];
	}

	// !!! Important !!!
	// To save gas on bulk ERC-20 & ERC-721 transfers, this method has been written in a way
	// that doesn't individually update a storage slot for each token owner but instead loops
	// through an array of holders in order to find a match.
	// As such it costs approximately 5k gas per loop (1 block = 30m gas = 6k loops) so having
	// another contract call this method could result in very large transaction fees. To prevent
	// this from happening, this method will block and revert if the caller is a contract.
	// !! This will break external contracts that use `ownerOf()` but queries outside of the
	// blockchain should not be effected !!
	//
	// If you need to externally check if a token is owned by a certain address, use the
	// new `isOwnerOf(address _user, uint256 _tokenId)` method instead.
	// Most current NFT based contracts don't use `ownerOf()` and assume that if a call
	// to `transferFrom()` was successful then `_from` was in fact the owner.
	function ownerOf(uint256 _tokenId) public view returns (address) {
		unchecked {
			uint32 _size;
			assembly {
				_size := caller()
			}
			require(_size == 0);
			require(_tokenId > totalSupply && _tokenId <= 2 * totalSupply);
			(uint256 _maskIndex, bytes32 _mask) = _tokenIdToMask(_tokenId);
			uint256 _holdersLength = info.holders.length;
			for (uint256 i = 0; i < _holdersLength; i++) {
				address _holder = info.holders[i];
				if (maskAtIndexOf(_maskIndex, _holder) & _mask == _mask) {
					return _holder;
				}
			}
			return address(0x0);
		}
	}

	function getApproved(uint256 _tokenId) public view returns (address) {
		unchecked {
			require(_tokenId > totalSupply && _tokenId <= 2 * totalSupply);
			return info.approved[_tokenId];
		}
	}

	function isApprovedForAll(address _owner, address _operator) public view returns (bool) {
		return info.users[_owner].approved[_operator];
	}

	function isOwnerOf(address _user, uint256 _tokenId) external view returns (bool) {
		unchecked {
			require(_tokenId > totalSupply && _tokenId <= 2 * totalSupply);
			(uint256 _maskIndex, bytes32 _mask) = _tokenIdToMask(_tokenId);
			return maskAtIndexOf(_maskIndex, _user) & _mask == _mask;
		}
	}

	function tokenByIndex(uint256 _index) external view returns (uint256) {
		unchecked {
			require(_index < totalSupply);
			return totalSupply + _index + 1;
		}
	}

	function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256 tokenId) {
		unchecked {
			require(_index < balanceOf(_owner));
			uint256 _count = 0;
			uint256 _activeMasks = uint224(info.users[_owner].activeMasks);
			while (_activeMasks > 0 && _count <= _index) {
				uint256 _activeIndex = _lsb(_activeMasks);
				_activeMasks ^= 1 << _activeIndex;
				bytes32 _mask = maskAtIndexOf(_activeIndex, _owner);
				uint256 _maskCount = _popcount(_mask);
				if (_count + _maskCount <= _index) {
					_count += _maskCount;
				} else {
					uint256 _n = uint256(_mask);
					while (_n > 0 && _count <= _index) {
						uint256 _pos = _lsb(_n);
						_n ^= 1 << _pos;
						_count++;
						if (_count == _index + 1) {
							return (MASK_SIZE * _activeIndex) + totalSupply + _pos + 1;
						}
					}
				}
			}
		}
	}

	function getToken(uint256 _tokenId, bool _getOwner) public view returns (address tokenOwner, address approved, string memory uri) {
		return (_getOwner ? ownerOf(_tokenId) : address(0x0), getApproved(_tokenId), tokenURI(_tokenId));
	}

	function getTokens(uint256[] memory _tokenIds, bool _getOwner) external view returns (address[] memory owners, address[] memory approveds, string[] memory uris) {
		uint256 _length = _tokenIds.length;
		owners = new address[](_length);
		approveds = new address[](_length);
		uris = new string[](_length);
		for (uint256 i = 0; i < _length; i++) {
			(owners[i], approveds[i], uris[i]) = getToken(_tokenIds[i], _getOwner);
		}
	}


	// Can be overridden by a parent contract if needed. Most of the logic inside this function is
	// essential for setting up the initial supply so be careful when altering it.
	// If all you want to do is save gas on deployment by preventing all the NFT `Transfer()` events
	// from emitting, use this in your parent contract:
	// `function initialize(...) external _withoutEventEmits { _initialize(_owner, _totalSupply); }`
	function _initialize(address _owner, uint256 _totalSupply) internal virtual {
		unchecked {
			require(totalSupply == 0);
			require(_totalSupply > 0 && _totalSupply <= MAX_ALLOWED_SUPPLY);
			info.owner = _owner;
			totalSupply = _totalSupply;
			maskDepth = ((_totalSupply - 1) / MASK_SIZE) + 1;
			supportsInterface[0x01ffc9a7] = true; // ERC-165
			supportsInterface[0x80ac58cd] = true; // ERC-721
			supportsInterface[0x5b5e139f] = true; // Metadata
			supportsInterface[0x780e9d63] = true; // Enumerable
			for (uint256 i = 0; i < maskDepth; i++) {
				if (i == maskDepth - 1 && _totalSupply % MASK_SIZE != 0) {
					info.users[_owner].masks[i] = bytes32(UINT_MAX) >> (MASK_SIZE - (_totalSupply % MASK_SIZE));
				} else {
					info.users[_owner].masks[i] = bytes32(UINT_MAX);
				}
			}
			info.users[_owner].balance = uint16(_totalSupply);
			info.users[_owner].activeMasks = bytes28(uint224(2**maskDepth - 1));
			info.holders.push(_owner);
			emit ERC20Transfer(TRANSFER_TOPIC, address(0x0), _owner, _totalSupply);
			if (!skipEventEmits) {
				for (uint256 i = 0; i < _totalSupply; i++) {
					emit Transfer(address(0x0), _owner, _totalSupply + i + 1);
				}
			}
		}
	}
	
	function _approveERC20(address _owner, address _spender, uint256 _tokens) internal {
		info.users[_owner].allowance[_spender] = _tokens;
		emit ERC20Approval(APPROVAL_TOPIC, _owner, _spender, _tokens);
	}

	function _approveNFT(address _spender, uint256 _tokenId) internal {
		unchecked {
			(uint256 _maskIndex, bytes32 _mask) = _tokenIdToMask(_tokenId);
			require(maskAtIndexOf(_maskIndex, msg.sender) & _mask == _mask);
			info.approved[_tokenId] = _spender;
			info.users[msg.sender].approvedCount++;
			emit Approval(msg.sender, _spender, _tokenId);
		}
	}
	
	// Can be overridden by a parent contract to change how token ids are selected when performing
	// an ERC-20 transfer. It is not recommended to do this unless you're sure you know what
	// the outcome will be and test it to make sure your implementation works as expected.
	function _transferERC20(address _from, address _to, uint256 _tokens) internal virtual {
		unchecked {
			uint256 _count = 0;
			uint256[] memory _tokenIds = new uint256[](_tokens);
			bytes32[] memory _masks = new bytes32[](maskDepth);
			uint256 _activeMasks = uint224(info.users[_from].activeMasks);
			while (_activeMasks > 0 && _count < _tokens) {
				uint256 _activeIndex = _lsb(_activeMasks);
				_activeMasks ^= 1 << _activeIndex;
				bytes32 _mask = maskAtIndexOf(_activeIndex, _from);
				uint256 _n = uint256(_mask);
				while (_n > 0 && _count < _tokens) {
					uint256 _pos = _lsb(_n);
					bytes32 _tokenMask = bytes32(1 << _pos);
					_masks[_activeIndex] |= _tokenMask;
					_tokenIds[_count++] = (MASK_SIZE * _activeIndex) + totalSupply + _pos + 1;
					_n ^= uint256(_tokenMask);
				}
				require(_mask & _masks[_activeIndex] == _masks[_activeIndex]);
			}
			require(_count == _tokens);
			_transfer(_from, _to, _masks, _tokenIds);
		}
	}
	
	function _transferNFT(address _from, address _to, uint256 _tokenId) internal {
		unchecked {
			require(_tokenId > totalSupply && _tokenId <= 2 * totalSupply);
			(uint256 _maskIndex, bytes32 _mask) = _tokenIdToMask(_tokenId);
			require(maskAtIndexOf(_maskIndex, _from) & _mask == _mask);
			require(msg.sender == _from || msg.sender == getApproved(_tokenId) || isApprovedForAll(_from, msg.sender));
			bytes32[] memory _masks = new bytes32[](maskDepth);
			_masks[_maskIndex] = _mask;
			uint256[] memory _tokenIds = new uint256[](1);
			_tokenIds[0] = _tokenId;
			_transfer(_from, _to, _masks, _tokenIds);
		}
	}
	
	function _transferNFTs(address _to, uint256[] memory _tokenIds) internal {
		unchecked {
			bytes32[] memory _masks = new bytes32[](maskDepth);
			for (uint256 i = 0; i < _tokenIds.length; i++) {
				(uint256 _maskIndex, bytes32 _mask) = _tokenIdToMask(_tokenIds[i]);
				_masks[_maskIndex] |= _mask;
			}
			uint256 _count = 0;
			for (uint256 i = 0; i < _masks.length; i++) {
				if (_masks[i] != 0x0) {
					require(maskAtIndexOf(i, msg.sender) & _masks[i] == _masks[i]);
					_count += _popcount(_masks[i]);
				}
			}
			require(_count == _tokenIds.length);
			_transfer(msg.sender, _to, _masks, _tokenIds);
		}
	}

	// Can be overridden by a parent contract in order to add some logic before the transfer completes. The
	// code here is important for the ERC-721 side of things so unless you explicitly want to change how this
	// works, you should always use `super._beforeTransfer(...);` in your overridden function.
	function _beforeTransfer(address _from, address _to, bytes32[] memory, uint256[] memory _tokenIds) internal virtual {
		unchecked {
			bool _skip = skipEventEmits;
			bool _skipApproveds = info.users[_from].approvedCount == 0;
			if (!(_skipApproveds && _skip)) {
				for (uint256 i = 0; i < _tokenIds.length; i++) {
					if (!_skipApproveds && getApproved(_tokenIds[i]) != address(0x0)) {
						info.users[_from].approvedCount--;
						info.approved[_tokenIds[i]] = address(0x0);
						emit Approval(address(0x0), address(0x0), _tokenIds[i]);
					}
					if (!_skip) {
						emit Transfer(_from, _to, _tokenIds[i]);
					}
				}
			}
		}
	}

	function _transfer(address _from, address _to, bytes32[] memory _masks, uint256[] memory _tokenIds) internal {
		unchecked {
			require(_to != address(0x0));
			require(_tokenIds.length > 0);
			_beforeTransfer(_from, _to, _masks, _tokenIds);
			uint256 _fromActive = uint224(info.users[_from].activeMasks);
			uint256 _toActive = uint224(info.users[_to].activeMasks);
			for (uint256 i = 0; i < _masks.length; i++) {
				if (_masks[i] != bytes32(0x0)) {
					bytes32 _fromMask = maskAtIndexOf(i, _from);
					_fromMask ^= _masks[i];
					info.users[_from].masks[i] = _fromMask;
					bytes32 _toMask = maskAtIndexOf(i, _to);
					_toMask |= _masks[i];
					info.users[_to].masks[i] = _toMask;
					if (_fromMask == 0x0) {
						_fromActive ^= 1 << i;
					}
					_toActive |= 1 << i;
					require(_fromMask & _toMask == 0x0);
				}
			}
			uint256 _fromBalance = balanceOf(_from);
			_fromBalance -= _tokenIds.length;
			info.users[_from].balance = uint16(_fromBalance);
			info.users[_from].activeMasks = bytes28(uint224(_fromActive));
			uint256 _toBalance = balanceOf(_to);
			info.users[_to].balance = uint16(_toBalance + _tokenIds.length);
			info.users[_to].activeMasks = bytes28(uint224(_toActive));
			if (_fromBalance == 0) {
				uint256 _index = info.indexOf[_from];
				if (_toBalance == 0) {
					info.holders[_index] = _to;
					info.indexOf[_to] = _index;
				} else {
					address _moved = info.holders[info.holders.length - 1];
					info.holders[_index] = _moved;
					info.indexOf[_moved] = _index;
					info.holders.pop();
				}
				delete info.indexOf[_from];
			} else if (_toBalance == 0) {
				info.holders.push(_to);
				info.indexOf[_to] = info.holders.length - 1;
			}
			emit ERC20Transfer(TRANSFER_TOPIC, _from, _to, _tokenIds.length);
			_afterTransfer(_from, _to, _masks, _tokenIds);
		}
	}

	// Can be overridden by a parent contract and used as a way to execute extra code after a transfer has completed.
	function _afterTransfer(address _from, address _to, bytes32[] memory _masks, uint256[] memory _tokenIds) internal virtual {}


	function _tokenIdToMask(uint256 _tokenId) internal view returns (uint256 maskIndex, bytes32 mask) {
		unchecked {
			maskIndex = (_tokenId - totalSupply - 1) / MASK_SIZE;
			mask = bytes32(1 << (_tokenId - (MASK_SIZE * maskIndex) - totalSupply - 1));
		}
	}
	
	function _popcount(bytes32 _b) internal pure returns (uint256) {
		unchecked {
			uint256 _n = uint256(_b);
			if (_n == 0) {
				return 0;
			} else if (_n == UINT_MAX) {
				return MASK_SIZE;
			}
			_n -= (_n >> 1) & M1;
			_n = (_n & M2) + ((_n >> 2) & M2);
			_n = (_n + (_n >> 4)) & M4;
			_n = (_n * H01) >> 248;
			return _n;
		}
	}


	// An extremely gas efficient implementation of the least significant bit algorithm. Due to all of
	// the constants in the if/else binary search tree, this function does add approximately 1.1m gas
	// to the deployment cost (~0.022 ETH @ 20 Gwei) but the end users will save on transaction fees.
	// The 'break even' point is around 3,000 total transfer volume where by you spending the extra to
	// make it more efficient, you have saved your end users more than you initially paid.
	// If you would rather have cheaper deployment costs and slightly less efficient transfers, replace
	// the entire `_lsb()` function with the one commented below:
	// ```function _lsb(uint256 _n) internal pure returns (uint256 i) {
	// 	unchecked { uint256 _b = _n & ~(_n - 1); i = 0;
	// 	for (uint256 _s = 0x80; _s > 0; _s >>= 1) { if (_b >= (1 << _s)) { _b >>= _s; i |= _s; } } }
	// }```
	function _lsb(uint256 _n) internal pure returns (uint256 i) {
		unchecked {
			uint256 _b = _n & ~(_n - 1);
			if (_b < 0x0100000000000000000000000000000000)
				if (_b < 0x010000000000000000)
					if (_b < 0x0100000000)
						if (_b < 0x010000)
							if (_b < 0x0100)
								if (_b < 0x10)
									if (_b < 0x04)
										if (_b < 0x02) return 0; else return 1;
									else
										if (_b < 0x08) return 2; else return 3;
								else
									if (_b < 0x40)
										if (_b < 0x20) return 4; else return 5;
									else
										if (_b < 0x80) return 6; else return 7;
							else
								if (_b < 0x1000)
									if (_b < 0x0400)
										if (_b < 0x0200) return 8; else return 9;
									else
										if (_b < 0x0800) return 10; else return 11;
								else
									if (_b < 0x4000)
										if (_b < 0x2000) return 12; else return 13;
									else
										if (_b < 0x8000) return 14; else return 15;
						else
							if (_b < 0x01000000)
								if (_b < 0x100000)
									if (_b < 0x040000)
										if (_b < 0x020000) return 16; else return 17;
									else
										if (_b < 0x080000) return 18; else return 19;
								else
									if (_b < 0x400000)
										if (_b < 0x200000) return 20; else return 21;
									else
										if (_b < 0x800000) return 22; else return 23;
							else
								if (_b < 0x10000000)
									if (_b < 0x04000000)
										if (_b < 0x02000000) return 24; else return 25;
									else
										if (_b < 0x08000000) return 26; else return 27;
								else
									if (_b < 0x40000000)
										if (_b < 0x20000000) return 28; else return 29;
									else
										if (_b < 0x80000000) return 30; else return 31;
					else
						if (_b < 0x01000000000000)
							if (_b < 0x010000000000)
								if (_b < 0x1000000000)
									if (_b < 0x0400000000)
										if (_b < 0x0200000000) return 32; else return 33;
									else
										if (_b < 0x0800000000) return 34; else return 35;
								else
									if (_b < 0x4000000000)
										if (_b < 0x2000000000) return 36; else return 37;
									else
										if (_b < 0x8000000000) return 38; else return 39;
							else
								if (_b < 0x100000000000)
									if (_b < 0x040000000000)
										if (_b < 0x020000000000) return 40; else return 41;
									else
										if (_b < 0x080000000000) return 42; else return 43;
								else
									if (_b < 0x400000000000)
										if (_b < 0x200000000000) return 44; else return 45;
									else
										if (_b < 0x800000000000) return 46; else return 47;
						else
							if (_b < 0x0100000000000000)
								if (_b < 0x10000000000000)
									if (_b < 0x04000000000000)
										if (_b < 0x02000000000000) return 48; else return 49;
									else
										if (_b < 0x08000000000000) return 50; else return 51;
								else
									if (_b < 0x40000000000000)
										if (_b < 0x20000000000000) return 52; else return 53;
									else
										if (_b < 0x80000000000000) return 54; else return 55;
							else
								if (_b < 0x1000000000000000)
									if (_b < 0x0400000000000000)
										if (_b < 0x0200000000000000) return 56; else return 57;
									else
										if (_b < 0x0800000000000000) return 58; else return 59;
								else
									if (_b < 0x4000000000000000)
										if (_b < 0x2000000000000000) return 60; else return 61;
									else
										if (_b < 0x8000000000000000) return 62; else return 63;
				else
					if (_b < 0x01000000000000000000000000)
						if (_b < 0x0100000000000000000000)
							if (_b < 0x01000000000000000000)
								if (_b < 0x100000000000000000)
									if (_b < 0x040000000000000000)
										if (_b < 0x020000000000000000) return 64; else return 65;
									else
										if (_b < 0x080000000000000000) return 66; else return 67;
								else
									if (_b < 0x400000000000000000)
										if (_b < 0x200000000000000000) return 68; else return 69;
									else
										if (_b < 0x800000000000000000) return 70; else return 71;
							else
								if (_b < 0x10000000000000000000)
									if (_b < 0x04000000000000000000)
										if (_b < 0x02000000000000000000) return 72; else return 73;
									else
										if (_b < 0x08000000000000000000) return 74; else return 75;
								else
									if (_b < 0x40000000000000000000)
										if (_b < 0x20000000000000000000) return 76; else return 77;
									else
										if (_b < 0x80000000000000000000) return 78; else return 79;
						else
							if (_b < 0x010000000000000000000000)
								if (_b < 0x1000000000000000000000)
									if (_b < 0x0400000000000000000000)
										if (_b < 0x0200000000000000000000) return 80; else return 81;
									else
										if (_b < 0x0800000000000000000000) return 82; else return 83;
								else
									if (_b < 0x4000000000000000000000)
										if (_b < 0x2000000000000000000000) return 84; else return 85;
									else
										if (_b < 0x8000000000000000000000) return 86; else return 87;
							else
								if (_b < 0x100000000000000000000000)
									if (_b < 0x040000000000000000000000)
										if (_b < 0x020000000000000000000000) return 88; else return 89;
									else
										if (_b < 0x080000000000000000000000) return 90; else return 91;
								else
									if (_b < 0x400000000000000000000000)
										if (_b < 0x200000000000000000000000) return 92; else return 93;
									else
										if (_b < 0x800000000000000000000000) return 94; else return 95;
					else
						if (_b < 0x010000000000000000000000000000)
							if (_b < 0x0100000000000000000000000000)
								if (_b < 0x10000000000000000000000000)
									if (_b < 0x04000000000000000000000000)
										if (_b < 0x02000000000000000000000000) return 96; else return 97;
									else
										if (_b < 0x08000000000000000000000000) return 98; else return 99;
								else
									if (_b < 0x40000000000000000000000000)
										if (_b < 0x20000000000000000000000000) return 100; else return 101;
									else
										if (_b < 0x80000000000000000000000000) return 102; else return 103;
							else
								if (_b < 0x1000000000000000000000000000)
									if (_b < 0x0400000000000000000000000000)
										if (_b < 0x0200000000000000000000000000) return 104; else return 105;
									else
										if (_b < 0x0800000000000000000000000000) return 106; else return 107;
								else
									if (_b < 0x4000000000000000000000000000)
										if (_b < 0x2000000000000000000000000000) return 108; else return 109;
									else
										if (_b < 0x8000000000000000000000000000) return 110; else return 111;
						else
							if (_b < 0x01000000000000000000000000000000)
								if (_b < 0x100000000000000000000000000000)
									if (_b < 0x040000000000000000000000000000)
										if (_b < 0x020000000000000000000000000000) return 112; else return 113;
									else
										if (_b < 0x080000000000000000000000000000) return 114; else return 115;
								else
									if (_b < 0x400000000000000000000000000000)
										if (_b < 0x200000000000000000000000000000) return 116; else return 117;
									else
										if (_b < 0x800000000000000000000000000000) return 118; else return 119;
							else
								if (_b < 0x10000000000000000000000000000000)
									if (_b < 0x04000000000000000000000000000000)
										if (_b < 0x02000000000000000000000000000000) return 120; else return 121;
									else
										if (_b < 0x08000000000000000000000000000000) return 122; else return 123;
								else
									if (_b < 0x40000000000000000000000000000000)
										if (_b < 0x20000000000000000000000000000000) return 124; else return 125;
									else
										if (_b < 0x80000000000000000000000000000000) return 126; else return 127;
			else
				if (_b < 0x01000000000000000000000000000000000000000000000000)
					if (_b < 0x010000000000000000000000000000000000000000)
						if (_b < 0x01000000000000000000000000000000000000)
							if (_b < 0x010000000000000000000000000000000000)
								if (_b < 0x1000000000000000000000000000000000)
									if (_b < 0x0400000000000000000000000000000000)
										if (_b < 0x0200000000000000000000000000000000) return 128; else return 129;
									else
										if (_b < 0x0800000000000000000000000000000000) return 130; else return 131;
								else
									if (_b < 0x4000000000000000000000000000000000)
										if (_b < 0x2000000000000000000000000000000000) return 132; else return 133;
									else
										if (_b < 0x8000000000000000000000000000000000) return 134; else return 135;
							else
								if (_b < 0x100000000000000000000000000000000000)
									if (_b < 0x040000000000000000000000000000000000)
										if (_b < 0x020000000000000000000000000000000000) return 136; else return 137;
									else
										if (_b < 0x080000000000000000000000000000000000) return 138; else return 139;
								else
									if (_b < 0x400000000000000000000000000000000000)
										if (_b < 0x200000000000000000000000000000000000) return 140; else return 141;
									else
										if (_b < 0x800000000000000000000000000000000000) return 142; else return 143;
						else
							if (_b < uint160(0x0100000000000000000000000000000000000000))
								if (_b < 0x10000000000000000000000000000000000000)
									if (_b < 0x04000000000000000000000000000000000000)
										if (_b < 0x02000000000000000000000000000000000000) return 144; else return 145;
									else
										if (_b < 0x08000000000000000000000000000000000000) return 146; else return 147;
								else
									if (_b < 0x40000000000000000000000000000000000000)
										if (_b < 0x20000000000000000000000000000000000000) return 148; else return 149;
									else
										if (_b < 0x80000000000000000000000000000000000000) return 150; else return 151;
							else
								if (_b < uint160(0x1000000000000000000000000000000000000000))
									if (_b < uint160(0x0400000000000000000000000000000000000000))
										if (_b < uint160(0x0200000000000000000000000000000000000000)) return 152; else return 153;
									else
										if (_b < uint160(0x0800000000000000000000000000000000000000)) return 154; else return 155;
								else
									if (_b < uint160(0x4000000000000000000000000000000000000000))
										if (_b < uint160(0x2000000000000000000000000000000000000000)) return 156; else return 157;
									else
										if (_b < uint160(0x8000000000000000000000000000000000000000)) return 158; else return 159;
					else
						if (_b < 0x0100000000000000000000000000000000000000000000)
							if (_b < 0x01000000000000000000000000000000000000000000)
								if (_b < 0x100000000000000000000000000000000000000000)
									if (_b < 0x040000000000000000000000000000000000000000)
										if (_b < 0x020000000000000000000000000000000000000000) return 160; else return 161;
									else
										if (_b < 0x080000000000000000000000000000000000000000) return 162; else return 163;
								else
									if (_b < 0x400000000000000000000000000000000000000000)
										if (_b < 0x200000000000000000000000000000000000000000) return 164; else return 165;
									else
										if (_b < 0x800000000000000000000000000000000000000000) return 166; else return 167;
							else
								if (_b < 0x10000000000000000000000000000000000000000000)
									if (_b < 0x04000000000000000000000000000000000000000000)
										if (_b < 0x02000000000000000000000000000000000000000000) return 168; else return 169;
									else
										if (_b < 0x08000000000000000000000000000000000000000000) return 170; else return 171;
								else
									if (_b < 0x40000000000000000000000000000000000000000000)
										if (_b < 0x20000000000000000000000000000000000000000000) return 172; else return 173;
									else
										if (_b < 0x80000000000000000000000000000000000000000000) return 174; else return 175;
						else
							if (_b < 0x010000000000000000000000000000000000000000000000)
								if (_b < 0x1000000000000000000000000000000000000000000000)
									if (_b < 0x0400000000000000000000000000000000000000000000)
										if (_b < 0x0200000000000000000000000000000000000000000000) return 176; else return 177;
									else
										if (_b < 0x0800000000000000000000000000000000000000000000) return 178; else return 179;
								else
									if (_b < 0x4000000000000000000000000000000000000000000000)
										if (_b < 0x2000000000000000000000000000000000000000000000) return 180; else return 181;
									else
										if (_b < 0x8000000000000000000000000000000000000000000000) return 182; else return 183;
							else
								if (_b < 0x100000000000000000000000000000000000000000000000)
									if (_b < 0x040000000000000000000000000000000000000000000000)
										if (_b < 0x020000000000000000000000000000000000000000000000) return 184; else return 185;
									else
										if (_b < 0x080000000000000000000000000000000000000000000000) return 186; else return 187;
								else
									if (_b < 0x400000000000000000000000000000000000000000000000)
										if (_b < 0x200000000000000000000000000000000000000000000000) return 188; else return 189;
									else
										if (_b < 0x800000000000000000000000000000000000000000000000) return 190; else return 191;
				else
					if (_b < 0x0100000000000000000000000000000000000000000000000000000000)
						if (_b < 0x010000000000000000000000000000000000000000000000000000)
							if (_b < 0x0100000000000000000000000000000000000000000000000000)
								if (_b < 0x10000000000000000000000000000000000000000000000000)
									if (_b < 0x04000000000000000000000000000000000000000000000000)
										if (_b < 0x02000000000000000000000000000000000000000000000000) return 192; else return 193;
									else
										if (_b < 0x08000000000000000000000000000000000000000000000000) return 194; else return 195;
								else
									if (_b < 0x40000000000000000000000000000000000000000000000000)
										if (_b < 0x20000000000000000000000000000000000000000000000000) return 196; else return 197;
									else
										if (_b < 0x80000000000000000000000000000000000000000000000000) return 198; else return 199;
							else
								if (_b < 0x1000000000000000000000000000000000000000000000000000)
									if (_b < 0x0400000000000000000000000000000000000000000000000000)
										if (_b < 0x0200000000000000000000000000000000000000000000000000) return 200; else return 201;
									else
										if (_b < 0x0800000000000000000000000000000000000000000000000000) return 202; else return 203;
								else
									if (_b < 0x4000000000000000000000000000000000000000000000000000)
										if (_b < 0x2000000000000000000000000000000000000000000000000000) return 204; else return 205;
									else
										if (_b < 0x8000000000000000000000000000000000000000000000000000) return 206; else return 207;
						else
							if (_b < 0x01000000000000000000000000000000000000000000000000000000)
								if (_b < 0x100000000000000000000000000000000000000000000000000000)
									if (_b < 0x040000000000000000000000000000000000000000000000000000)
										if (_b < 0x020000000000000000000000000000000000000000000000000000) return 208; else return 209;
									else
										if (_b < 0x080000000000000000000000000000000000000000000000000000) return 210; else return 211;
								else
									if (_b < 0x400000000000000000000000000000000000000000000000000000)
										if (_b < 0x200000000000000000000000000000000000000000000000000000) return 212; else return 213;
									else
										if (_b < 0x800000000000000000000000000000000000000000000000000000) return 214; else return 215;
							else
								if (_b < 0x10000000000000000000000000000000000000000000000000000000)
									if (_b < 0x04000000000000000000000000000000000000000000000000000000)
										if (_b < 0x02000000000000000000000000000000000000000000000000000000) return 216; else return 217;
									else
										if (_b < 0x08000000000000000000000000000000000000000000000000000000) return 218; else return 219;
								else
									if (_b < 0x40000000000000000000000000000000000000000000000000000000)
										if (_b < 0x20000000000000000000000000000000000000000000000000000000) return 220; else return 221;
									else
										if (_b < 0x80000000000000000000000000000000000000000000000000000000) return 222; else return 223;
					else
						if (_b < 0x01000000000000000000000000000000000000000000000000000000000000)
							if (_b < 0x010000000000000000000000000000000000000000000000000000000000)
								if (_b < 0x1000000000000000000000000000000000000000000000000000000000)
									if (_b < 0x0400000000000000000000000000000000000000000000000000000000)
										if (_b < 0x0200000000000000000000000000000000000000000000000000000000) return 224; else return 225;
									else
										if (_b < 0x0800000000000000000000000000000000000000000000000000000000) return 226; else return 227;
								else
									if (_b < 0x4000000000000000000000000000000000000000000000000000000000)
										if (_b < 0x2000000000000000000000000000000000000000000000000000000000) return 228; else return 229;
									else
										if (_b < 0x8000000000000000000000000000000000000000000000000000000000) return 230; else return 231;
							else
								if (_b < 0x100000000000000000000000000000000000000000000000000000000000)
									if (_b < 0x040000000000000000000000000000000000000000000000000000000000)
										if (_b < 0x020000000000000000000000000000000000000000000000000000000000) return 232; else return 233;
									else
										if (_b < 0x080000000000000000000000000000000000000000000000000000000000) return 234; else return 235;
								else
									if (_b < 0x400000000000000000000000000000000000000000000000000000000000)
										if (_b < 0x200000000000000000000000000000000000000000000000000000000000) return 236; else return 237;
									else
										if (_b < 0x800000000000000000000000000000000000000000000000000000000000) return 238; else return 239;
						else
							if (_b < 0x0100000000000000000000000000000000000000000000000000000000000000)
								if (_b < 0x10000000000000000000000000000000000000000000000000000000000000)
									if (_b < 0x04000000000000000000000000000000000000000000000000000000000000)
										if (_b < 0x02000000000000000000000000000000000000000000000000000000000000) return 240; else return 241;
									else
										if (_b < 0x08000000000000000000000000000000000000000000000000000000000000) return 242; else return 243;
								else
									if (_b < 0x40000000000000000000000000000000000000000000000000000000000000)
										if (_b < 0x20000000000000000000000000000000000000000000000000000000000000) return 244; else return 245;
									else
										if (_b < 0x80000000000000000000000000000000000000000000000000000000000000) return 246; else return 247;
							else
								if (_b < 0x1000000000000000000000000000000000000000000000000000000000000000)
									if (_b < 0x0400000000000000000000000000000000000000000000000000000000000000)
										if (_b < 0x0200000000000000000000000000000000000000000000000000000000000000) return 248; else return 249;
									else
										if (_b < 0x0800000000000000000000000000000000000000000000000000000000000000) return 250; else return 251;
								else
									if (_b < 0x4000000000000000000000000000000000000000000000000000000000000000)
										if (_b < 0x2000000000000000000000000000000000000000000000000000000000000000) return 252; else return 253;
									else
										if (_b < 0x8000000000000000000000000000000000000000000000000000000000000000) return 254; else return 255;
		}
	}
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","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":true,"inputs":[{"indexed":true,"internalType":"bytes32","name":"topic0","type":"bytes32"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokens","type":"uint256"}],"name":"ERC20Approval","type":"event"},{"anonymous":true,"inputs":[{"indexed":true,"internalType":"bytes32","name":"topic0","type":"bytes32"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokens","type":"uint256"}],"name":"ERC20Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"LAUNCH_COST","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"address","name":"_spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_tokens","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"}],"name":"bulkTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"devTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"bool","name":"_getOwner","type":"bool"}],"name":"getToken","outputs":[{"internalType":"address","name":"tokenOwner","type":"address"},{"internalType":"address","name":"approved","type":"address"},{"internalType":"string","name":"uri","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"},{"internalType":"bool","name":"_getOwner","type":"bool"}],"name":"getTokens","outputs":[{"internalType":"address[]","name":"owners","type":"address[]"},{"internalType":"address[]","name":"approveds","type":"address[]"},{"internalType":"string[]","name":"uris","type":"string[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"holders","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialLiquidityETH","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialLiquidityTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string[4]","name":"_strings","type":"string[4]"},{"internalType":"uint256[4]","name":"_numbers","type":"uint256[4]"}],"name":"initialize","outputs":[],"stateMutability":"payable","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":"_user","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"isOwnerOf","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lpUnlockTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_index","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"maskAtIndexOf","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"masksOf","outputs":[{"internalType":"bytes32[]","name":"masks","type":"bytes32[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokens","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintableTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pair","outputs":[{"internalType":"contract Pair","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"remainingMintableTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"},{"internalType":"bool","name":"_approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseTokenURI","type":"string"}],"name":"setBaseTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_name","type":"string"}],"name":"setName","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"setOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_symbol","type":"string"}],"name":"setSymbol","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_tokenURISuffix","type":"string"}],"name":"setTokenURISuffix","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"skipInitialization","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"","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":"_index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenURISuffix","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_tokens","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_tokens","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unlockLP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]