File 1 of 1: Edgehogs.sol
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
pragma solidity ^0.8.0;
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
pragma solidity ^0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
pragma solidity ^0.8.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
_approve(address(0), tokenId);
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
pragma solidity ^0.8.4;
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
bool burned;
}
struct AddressData {
uint64 balance;
uint64 numberMinted;
uint64 numberBurned;
uint64 aux;
}
uint256 internal _currentIndex;
uint256 internal _burnCounter;
string private _name;
string private _symbol;
mapping(uint256 => TokenOwnership) internal _ownerships;
mapping(address => AddressData) private _addressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
_currentIndex = _startTokenId();
}
function _startTokenId() internal view virtual returns (uint256) {
return 0;
}
function totalSupply() public view returns (uint256) {
unchecked {
return _currentIndex - _burnCounter - _startTokenId();
}
}
function _totalMinted() internal view returns (uint256) {
unchecked {
return _currentIndex - _startTokenId();
}
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view override returns (uint256) {
if (owner == address(0)) revert BalanceQueryForZeroAddress();
return uint256(_addressData[owner].balance);
}
function _numberMinted(address owner) internal view returns (uint256) {
return uint256(_addressData[owner].numberMinted);
}
function _numberBurned(address owner) internal view returns (uint256) {
return uint256(_addressData[owner].numberBurned);
}
function _getAux(address owner) internal view returns (uint64) {
return _addressData[owner].aux;
}
function _setAux(address owner, uint64 aux) internal {
_addressData[owner].aux = aux;
}
function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
uint256 curr = tokenId;
unchecked {
if (_startTokenId() <= curr && curr < _currentIndex) {
TokenOwnership memory ownership = _ownerships[curr];
if (!ownership.burned) {
if (ownership.addr != address(0)) {
return ownership;
}
while (true) {
curr--;
ownership = _ownerships[curr];
if (ownership.addr != address(0)) {
return ownership;
}
}
}
}
}
revert OwnerQueryForNonexistentToken();
}
function ownerOf(uint256 tokenId) public view override returns (address) {
return _ownershipOf(tokenId).addr;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
if (!_exists(tokenId)) revert URIQueryForNonexistentToken();
string memory baseURI = _baseURI();
return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : '';
}
function _baseURI() internal view virtual returns (string memory) {
return '';
}
function approve(address to, uint256 tokenId) public override {
address owner = ERC721A.ownerOf(tokenId);
if (to == owner) revert ApprovalToCurrentOwner();
if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
revert ApprovalCallerNotOwnerNorApproved();
}
_approve(to, tokenId, owner);
}
function getApproved(uint256 tokenId) public view override returns (address) {
if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
if (operator == _msgSender()) revert ApproveToCaller();
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
_transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, '');
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
_transfer(from, to, tokenId);
if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
}
function _exists(uint256 tokenId) internal view returns (bool) {
return _startTokenId() <= tokenId && tokenId < _currentIndex && !_ownerships[tokenId].burned;
}
function _safeMint(address to, uint256 quantity) internal {
_safeMint(to, quantity, '');
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
uint256 startTokenId = _currentIndex;
if (to == address(0)) revert MintToZeroAddress();
if (quantity == 0) revert MintZeroQuantity();
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
unchecked {
_addressData[to].balance += uint64(quantity);
_addressData[to].numberMinted += uint64(quantity);
_ownerships[startTokenId].addr = to;
_ownerships[startTokenId].startTimestamp = uint64(block.timestamp);
uint256 updatedIndex = startTokenId;
uint256 end = updatedIndex + quantity;
if (to.isContract()) {
do {
emit Transfer(address(0), to, updatedIndex);
if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
} while (updatedIndex != end);
if (_currentIndex != startTokenId) revert();
} else {
do {
emit Transfer(address(0), to, updatedIndex++);
} while (updatedIndex != end);
}
_currentIndex = updatedIndex;
}
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
function _mint(address to, uint256 quantity) internal {
uint256 startTokenId = _currentIndex;
if (to == address(0)) revert MintToZeroAddress();
if (quantity == 0) revert MintZeroQuantity();
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
unchecked {
_addressData[to].balance += uint64(quantity);
_addressData[to].numberMinted += uint64(quantity);
_ownerships[startTokenId].addr = to;
_ownerships[startTokenId].startTimestamp = uint64(block.timestamp);
uint256 updatedIndex = startTokenId;
uint256 end = updatedIndex + quantity;
do {
emit Transfer(address(0), to, updatedIndex++);
} while (updatedIndex != end);
_currentIndex = updatedIndex;
}
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
function _transfer(
address from,
address to,
uint256 tokenId
) private {
TokenOwnership memory prevOwnership = _ownershipOf(tokenId);
if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();
bool isApprovedOrOwner = (_msgSender() == from ||
isApprovedForAll(from, _msgSender()) ||
getApproved(tokenId) == _msgSender());
if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
if (to == address(0)) revert TransferToZeroAddress();
_beforeTokenTransfers(from, to, tokenId, 1);
_approve(address(0), tokenId, from);
unchecked {
_addressData[from].balance -= 1;
_addressData[to].balance += 1;
TokenOwnership storage currSlot = _ownerships[tokenId];
currSlot.addr = to;
currSlot.startTimestamp = uint64(block.timestamp);
uint256 nextTokenId = tokenId + 1;
TokenOwnership storage nextSlot = _ownerships[nextTokenId];
if (nextSlot.addr == address(0)) {
if (nextTokenId != _currentIndex) {
nextSlot.addr = from;
nextSlot.startTimestamp = prevOwnership.startTimestamp;
}
}
}
emit Transfer(from, to, tokenId);
_afterTokenTransfers(from, to, tokenId, 1);
}
function _burn(uint256 tokenId) internal virtual {
_burn(tokenId, false);
}
function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
TokenOwnership memory prevOwnership = _ownershipOf(tokenId);
address from = prevOwnership.addr;
if (approvalCheck) {
bool isApprovedOrOwner = (_msgSender() == from ||
isApprovedForAll(from, _msgSender()) ||
getApproved(tokenId) == _msgSender());
if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
}
_beforeTokenTransfers(from, address(0), tokenId, 1);
_approve(address(0), tokenId, from);
unchecked {
AddressData storage addressData = _addressData[from];
addressData.balance -= 1;
addressData.numberBurned += 1;
TokenOwnership storage currSlot = _ownerships[tokenId];
currSlot.addr = from;
currSlot.startTimestamp = uint64(block.timestamp);
currSlot.burned = true;
uint256 nextTokenId = tokenId + 1;
TokenOwnership storage nextSlot = _ownerships[nextTokenId];
if (nextSlot.addr == address(0)) {
if (nextTokenId != _currentIndex) {
nextSlot.addr = from;
nextSlot.startTimestamp = prevOwnership.startTimestamp;
}
}
}
emit Transfer(from, address(0), tokenId);
_afterTokenTransfers(from, address(0), tokenId, 1);
unchecked {
_burnCounter++;
}
}
function _approve(
address to,
uint256 tokenId,
address owner
) private {
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function _checkContractOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert TransferToNonERC721ReceiverImplementer();
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
pragma solidity ^0.8.0;
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity ^0.8.0;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
bytes32 proofElement = proof[i];
if (computedHash <= proofElement) {
computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
} else {
computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
}
}
return computedHash;
}
}
contract OwnableDelegateProxy {}
contract OpenSeaProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
pragma solidity ^0.8.12;
interface InterfaceDescriptor {
function renderBottom(uint256 _bottom) external view returns (bytes memory);
function renderClothes(uint256 _clothes) external view returns (bytes memory);
function renderBack(uint256 _back) external view returns (bytes memory);
function renderAccessory(uint256 _accessory) external view returns (bytes memory);
function renderHeadgear(uint256 _headgear) external view returns (bytes memory);
function renderMouth(uint256 _mouth) external view returns (bytes memory);
function renderBackground(uint256 _background) external view returns (bytes memory);
function renderEyes(uint256 _eyes) external view returns (bytes memory);
function renderLegendary(uint256 _legendary) external view returns (bytes memory);
}
contract Edgehogs is Ownable, ERC721A {
uint256 public MAX = 6666;
uint256 public MAX_FREE = 696;
uint256 public MAX_REROLLS = 1000;
uint256 public PURCHASE_LIMIT = 10;
uint256 public PRICE = 0.025 ether;
uint256 public REROLL_PRICE = 0.01 ether;
uint256 public mintedTokens;
uint256 public rerollsMade;
uint256 public freeClaimed;
uint8 public saleState = 0;
bool public isOpenSeaApproved;
bool public legendariesSet = false;
OpenSeaProxyRegistry public openSeaProxyRegistry;
address t1 = 0x392D50fCFDd5b36E6DdDB22bcB84AA80B8105890;
address t2 = 0xE0b76103Ec5d8159939572A61286bD3291DB8a43;
address steveAoki = 0xe4bBCbFf51e61D0D95FcC5016609aC8354B177C4;
mapping(uint256 => uint256) public tokenSeed;
mapping(address => uint256) public whitelistMints;
InterfaceDescriptor public descriptor;
uint16[][8] rarities;
string[][9] traitsByName;
uint256[] legendaryList;
mapping (uint256 => string) private _tokenName;
mapping (string => bool) private _nameReserved;
bytes32 internal _merkleRoot;
string private constant svgStart =
"<svg id='edgehog' xmlns='http://www.w3.org/2000/svg' viewBox='0 0 256 256' width='640' height='640'>";
string private constant svgEnd =
"<style>#edgehog{shape-rendering: crispedges; image-rendering: -moz-crisp-edges; image-rendering: optimizeSpeed; image-rendering: -webkit-crisp-edges; image-rendering: -webkit-optimize-contrast; image-rendering: crisp-edges; image-rendering: pixelated; -ms-interpolation-mode: nearest-neighbor;}.vibe { animation: 0.5s vibe infinite alternate ease-in-out; } @keyframes vibe { from { transform: translateY(0px); } to { transform: translateY(1.5%); } }</style></svg>";
string private constant _body =
"<image href='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQAAAAEABAMAAACuXLVVAAAAD1BMVEUAAACTg2rLtaEnDQhZVlIUtesvAAAAAXRSTlMAQObYZgAAAMhJREFUeNrt2bENxCAQRUG3QAvXAi24/5oOS15hmdNB6vVMQkDwXwwbAAAAAAAAAAAAAAAAAAAAAMCq2uzNtkiAAAG5AmI8bBMCBAjIG1BOswgBAgTkCujjo/2H2ggQICB/wOemnAQIEJAvYD4+RtSTAAEC3hdwiIA4BQgQkCfgUBsBAgS8N6A0AgQIEDALKI0AAQJyBoRysfpAIUCAgOcH/Pu4vI+HGBcgQED+gG4cFyBAQN6AOoi7Pi5AgID8Adc7AQIEpAj4AjgSOK7j5zUdAAAAAElFTkSuQmCC'/>";
string private constant _head =
"<g class='vibe'><image href='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQAAAAEABAMAAACuXLVVAAAAFVBMVEUAAADLtaEnDQiTg2rsmJkAAABZVlL0LlrIAAAAAXRSTlMAQObYZgAAALBJREFUeNrt1s0JwzAMgNGukBWyQlfoCl2h+4/QGCwQAZOfm5X3rpHQdwp+AQAAAAAAAAAAAJyxJnf3BAgQMH/Ap7uyFzsCBAiYPyBHvLsliZklaTP5uAABAuYPiIh0fCgifxsBAgQ8LyB/FyBAwDMDGgECBNQP2Bs9SOK4AAEC6gQ0o6Ph2wkQIKBuwOiHFMdDPi5AgIB6Ac16YD8vQICAegEAAAAAAAAAAAAAAEAZf88p+dDBeVtDAAAAAElFTkSuQmCC'/></g>";
constructor(
InterfaceDescriptor descriptor_,
OpenSeaProxyRegistry openSeaProxyRegistry_,
bytes32 merkleRoot_
) ERC721A("EDGEHOGS", unicode"⚉") {
descriptor = descriptor_;
openSeaProxyRegistry = openSeaProxyRegistry_;
_merkleRoot = merkleRoot_;
rarities[0] = [0,
200,
2000,
2000,
2000,
2000,
900,
900
];
rarities[1] = [
0,
1000,
850,
700,
700,
700,
600,
600,
500,
500,
400,
400,
300,
300,
300,
300,
300,
300,
200,
200,
200,
200,
200,
100,
100,
50
];
rarities[2] = [
0,
550,
550,
550,
550,
550,
550,
550,
550,
550,
500,
500,
500,
500,
500,
500,
500,
500,
500,
500,
50
];
rarities[3] = [
0,
550,
550,
550,
550,
550,
550,
550,
550,
550,
500,
500,
500,
500,
500,
500,
500,
500,
500,
500,
50
];
rarities[4] = [
0,
1000,
800,
800,
800,
600,
600,
500,
500,
400,
400,
400,
400,
400,
300,
300,
300,
300,
300,
200,
200,
200,
150,
100,
50
];
rarities[5] = [
0,
800,
600,
600,
600,
600,
600,
400,
400,
400,
400,
300,
300,
300,
300,
300,
200,
200,
200,
200,
200,
200,
200,
200,
200,
200,
200,
100,
100,
100,
100,
100,
100,
100,
50,
50,
50,
50
];
rarities[6] = [
0,
850,
800,
800,
600,
600,
600,
400,
400,
400,
400,
300,
300,
300,
300,
300,
200,
200,
200,
200,
200,
200,
200,
200,
200,
100,
100,
100,
100,
100,
100,
100,
100,
50
];
rarities[7] = [
0,
800,
700,
700,
700,
700,
500,
500,
500,
500,
500,
500,
500,
400,
400,
400,
300,
200,
200,
200,
200,
200,
100,
100,
100,
50,
50
];
traitsByName[0] = [
"n/a",
"Psychedelic",
"Purple",
"Orange",
"Green",
"Pink",
"Pink-Blue",
"Blue-Green"
];
traitsByName[1] = [
"n/a",
"Edgehog",
"Firework",
"Black",
"Neon Sparks",
"Shoomery",
"Pirate",
"Punk",
"Grant us Eyes",
"Rainbow",
"Neon Punk",
"Psychedelic",
"Slime",
"Spotty",
"Christmas",
"Brainiac",
"Cyberhog",
"Bubble gum",
"Skellyhog",
"TNT",
"Biohazard",
"Robohog",
"Hellhog",
"Virus",
"Pure Gold",
"Diamond"
];
traitsByName[2] = [
"n/a",
"Fancy",
"Padre",
"Joker",
"Vault Dweller",
"Santa",
"Torn Jeans",
"Fishnets",
"Bikini",
"Green",
"Pajamas",
"BDSM",
"Mime",
"Pink",
"Jungle",
"Rainbow",
"Elvis",
"Bathog",
"Partyhog",
"Skelly",
"Pure Gold"
];
traitsByName[3] = [
"n/a",
"Pink",
"Joker",
"Vault Dweller",
"Padre",
"Santa",
"Freddy",
"Pierced Nips",
"Bikini",
"Punk",
"Pajamas",
"BDSM",
"Mime",
"Rapper",
"Buff",
"Rainbow",
"Elvis",
"Bathog",
"Partyhog",
"Skelly",
"Pure Gold"
];
traitsByName[4] = [
"None",
"Plain",
"Smile",
"Drooling",
"Tongue",
"Pipe",
"Party",
"Love",
"Zombie",
"Rabid",
"Blush",
"Mime",
"Bubble gum",
"Blunt",
"Bloody",
"Licker",
"Vampire",
"Blotter",
"Virus",
"Red Beard",
"Golden tooth",
"TNT",
"Hannibal",
"Biohazard",
"Laser"
];
traitsByName[5] = [
"n/a",
"None",
"Beanie",
"Fastfood",
"Apple",
"Frying pan",
"Tinfoil hat",
"Arrow",
"Punk",
"Rabbit ears",
"Doc",
"Pizza",
"Anntennae",
"Horny",
"Pretty bow",
"Eye",
"Devil",
"Skull",
"Toad",
"Unicorn",
"Kamikaze",
"Santa",
"Pirate",
"Alien eyes",
"Demon",
"Crown",
"Chief",
"Zombie hand",
"Fake halo",
"Brainz",
"Strawberry cap",
"Russian hat",
"Frankenhog",
"Plunger",
"Sroomhead",
"Octopus",
"Plague Doctor",
"VR"
];
traitsByName[6] = [
"n/a",
"Plain",
"Sus",
"Green",
"Crosseyed",
"Angry",
"Kawaii",
"Tired",
"Grumpy",
"Red goggles",
"Green goggles",
"Bloodshot",
"Goomba",
"Eye patch",
"Squinty",
"Insane",
"Vampire",
"Pop out",
"Popeye",
"Dizzy",
"Triple eye",
"Hearts",
"XX",
"Alien",
"VR goggles",
"Cyclops",
"Rainbow goggles",
"Cyborg",
"Cyberhog",
"Demon",
"Hogminator",
"Steampunk",
"Deal with it",
"Lasers"
];
traitsByName[7] = [
"n/a",
"None",
"Coffee",
"Sausage",
"Sorcerer staff",
"Mana potion",
"Bong",
"Pirate flag",
"Whip",
"Beer",
"Steel claws",
"Trident",
"Knife",
"Club",
"Balloon",
"Shocker",
"Biohazard",
"Lightsaber",
"Master Sword",
"Doggy",
"Rose",
"Gun",
"Pee",
"Chainsaw",
"Scythe",
"Dildo",
"Minigun"
];
traitsByName[8] = [
"n/a",
"Nude Dude",
"Dark Entity",
"Acid Hog",
"Zombie Hog",
"Hog Spirit",
"Lava Hog",
"Why So Serious",
"Robohog",
"Very Fast Blue Hog",
"Retrohog"
];
}
function _getTrait(uint256 _trait, uint256 index)
internal
view
returns (string memory)
{
return traitsByName[_trait][index];
}
function getTraits(uint256 seed)
public
view
returns (string memory svg, string memory properties)
{
uint16[] memory randomInputs = expand(seed, 8);
uint16[] memory traits = new uint16[](9);
if (seed > 100) {
traits[0] = getRandomIndex(rarities[0], randomInputs[0]);
traits[1] = getRandomIndex(rarities[1], randomInputs[1]);
traits[2] = getRandomIndex(rarities[2], randomInputs[2]);
traits[3] = getRandomIndex(rarities[3], randomInputs[3]);
traits[4] = getRandomIndex(rarities[4], randomInputs[4]);
traits[5] = getRandomIndex(rarities[5], randomInputs[5]);
traits[6] = getRandomIndex(rarities[6], randomInputs[6]);
traits[7] = getRandomIndex(rarities[7], randomInputs[7]);
traits[8] = 0;
if (traits[1] == 19 || traits[1] == 22) {
traits[5] = 1;
}
if (traits[4] == 21) {
traits[7] = 0;
}
if (traits[7] == 4 || traits[7] == 24) {
traits[4] = 1;
}
if (traits[5] == 37) {
traits[6] = 1;
}
if (traits[5] == 36) {
traits[6] = 1;
traits[4] = 0;
}
} else {
traits[0] = 0;
traits[1] = 0;
traits[2] = 0;
traits[3] = 0;
traits[4] = 0;
traits[5] = 0;
traits[6] = 0;
traits[7] = 0;
traits[8] = uint16(seed);
}
bytes memory _svg = renderEdgehog(
traits[0],
traits[1],
traits[2],
traits[3],
traits[4],
traits[5],
traits[6],
traits[7],
traits[8]
);
svg = base64(_svg);
if (seed > 100) {
bytes memory _properties = abi.encodePacked(
packMetaData("background", _getTrait(0, traits[0]), 0),
packMetaData("back", _getTrait(1, traits[1]), 0),
packMetaData("bottom", _getTrait(2, traits[2]), 0),
packMetaData("clothes", _getTrait(3, traits[3]), 0),
packMetaData("mouth", _getTrait(4, traits[4]), 0),
packMetaData("headgear", _getTrait(5, traits[5]), 0),
packMetaData("eyes", _getTrait(6, traits[6]), 0),
packMetaData("accessory", _getTrait(7, traits[7]), 1)
);
properties = string(abi.encodePacked(_properties));
} else {
bytes memory _properties = abi.encodePacked(
packMetaData("legendary", _getTrait(8, seed), 1)
);
properties = string(abi.encodePacked(_properties));
}
return (svg, properties);
}
function getRandomIndex(
uint16[] memory attributeRarities,
uint256 randomNumber
) private pure returns (uint16 index) {
uint16 random10k = uint16(randomNumber % 10000);
uint16 lowerBound;
for (uint16 i = 1; i <= attributeRarities.length; i++) {
uint16 percentage = attributeRarities[i];
if (random10k < percentage + lowerBound && random10k >= lowerBound) {
return i;
}
lowerBound = lowerBound + percentage;
}
revert();
}
function renderEdgehog(
uint16 _background,
uint16 _back,
uint16 _bottom,
uint16 _clothes,
uint16 _mouth,
uint16 _headgear,
uint16 _eyes,
uint16 _accessory,
uint16 _legendary
) public view returns (bytes memory) {
bytes memory start = abi.encodePacked(
svgStart,
descriptor.renderBackground(_background),
descriptor.renderBack(_back),
_body,
descriptor.renderBottom(_bottom)
);
return
abi.encodePacked(
start,
descriptor.renderClothes(_clothes),
_head,
descriptor.renderAccessory(_accessory),
descriptor.renderHeadgear(_headgear),
descriptor.renderEyes(_eyes),
descriptor.renderMouth(_mouth),
descriptor.renderLegendary(_legendary),
svgEnd
);
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
require(_exists(tokenId), "Token not found");
(string memory svg, string memory properties) = getTraits(
tokenSeed[tokenId]
);
return
string(
abi.encodePacked(
"data:application/json;base64,",
base64(
abi.encodePacked(
'{"name":"Edgehog #',
uint2str(tokenId),' ',_tokenName[tokenId],
'", "description": "Edgehogs live on the cutting edge of Ethereum blockchain and are edgy as hell.", "traits": [',
properties,
'], "image":"data:image/svg+xml;base64,',
svg,
'"}'
)
)
)
);
}
function packMetaData(
string memory name,
string memory svg,
uint256 last
) private pure returns (bytes memory) {
string memory comma = ",";
if (last > 0) comma = "";
return
abi.encodePacked(
'{"trait_type": "',
name,
'", "value": "',
svg,
'"}',
comma
);
}
function gift(uint256 numberOfTokens, address recipient) external onlyOwner {
uint256 supply = totalSupply();
require(supply + numberOfTokens <= MAX, "Would exceed max supply");
for (uint256 i = 0; i < numberOfTokens; i++) {
tokenSeed[supply + i] = uint256(
keccak256(abi.encodePacked(block.timestamp, msg.sender, supply + i))
);
}
delete supply;
_safeMint(recipient, numberOfTokens);
}
function mint(uint256 numberOfTokens) external payable {
uint256 supply = totalSupply();
require(saleState == 1, "Sale inactive");
require(msg.sender != steveAoki, "No Steve Aoki!");
require(numberOfTokens <= PURCHASE_LIMIT, "Too many");
require(supply + numberOfTokens <= MAX - MAX_FREE + freeClaimed, "Would exceed max public supply");
require(PRICE * numberOfTokens == msg.value, "Wrong ETH amount");
for (uint256 i = 0; i < numberOfTokens; i++) {
tokenSeed[supply + i] = uint256(
keccak256(abi.encodePacked(block.timestamp, msg.sender, supply + i))
);
}
delete supply;
_safeMint(msg.sender, numberOfTokens);
}
function presaleMint(bytes32[] calldata proof_) external {
uint256 supply = totalSupply();
require(saleState == 1, "Sale inactive");
require(supply + 1 <= MAX, "Would exceed max supply");
require(isWhitelisted(msg.sender, proof_), "Not on the list");
require(whitelistMints[msg.sender] == 0, "Already minted");
freeClaimed++;
whitelistMints[msg.sender]++;
tokenSeed[supply] = uint256(
keccak256(abi.encodePacked(block.timestamp, msg.sender, supply))
);
delete supply;
_safeMint(msg.sender, 1);
}
function reroll(uint256 _tokenId) external payable {
require(saleState == 2, "Reroll inactive");
require(rerollsMade < MAX_REROLLS, "No more rerolls");
require(msg.sender == ownerOf(_tokenId), "Only owner can reroll");
require(!isLegendary(_tokenId), "Can't be rerolled");
require(REROLL_PRICE == msg.value, "Wrong ETH amount");
rerollsMade = rerollsMade + 1;
tokenSeed[_tokenId] = uint256(
keccak256(abi.encodePacked(block.timestamp, msg.sender, _tokenId + 1))
);
}
function rollLegendary(uint256 _tokenId, uint256 _legendaryId) public onlyOwner {
require(!isLegendary(_tokenId), "Can't be upgraded");
tokenSeed[_tokenId] = _legendaryId;
addLegendaryNumber(_legendaryId);
}
function isLegendary(uint256 _tokenId) public view returns (bool) {
if (tokenSeed[_tokenId] <=100) {
return true;
} else {
return false;
}
}
function setLegendaries(uint256 _legendarySeed) public onlyOwner {
require(legendariesSet == false, "Legendaries already set");
uint256 s = totalSupply();
uint256 n = _legendarySeed;
for (uint256 i = 1; i <= 10; i++) {
uint256 randomNumber = uint256(keccak256(abi.encodePacked(block.timestamp,msg.sender,n))) % s;
if (!isLegendary(randomNumber)) {
tokenSeed[randomNumber] = i;
addLegendaryNumber(randomNumber);
n = n * 6;
}
}
delete s;
delete n;
legendariesSet = true;
}
function changeName(uint256 tokenId, string memory newName) public {
address owner = ownerOf(tokenId);
require(_msgSender() == owner, "ERC721: caller is not the owner");
require(validateName(newName) == true, "Not a valid new name");
require(sha256(bytes(newName)) != sha256(bytes(_tokenName[tokenId])), "New name is same as the current one");
require(isNameReserved(newName) == false, "Name already reserved");
if (bytes(_tokenName[tokenId]).length > 0) {
toggleReserveName(_tokenName[tokenId], false);
}
toggleReserveName(newName, true);
_tokenName[tokenId] = newName;
emit NameChange(tokenId, newName);
}
event NameChange (uint256 indexed edgehogId, string newName);
function tokenNameByIndex(uint256 index) public view returns (string memory) {
return _tokenName[index];
}
function isNameReserved(string memory nameString) public view returns (bool) {
return _nameReserved[toLower(nameString)];
}
function toggleReserveName(string memory str, bool isReserve) internal {
_nameReserved[toLower(str)] = isReserve;
}
function validateName(string memory str) public pure returns (bool){
bytes memory b = bytes(str);
if(b.length < 1) return false;
if(b.length > 25) return false;
if(b[0] == 0x20) return false;
if (b[b.length - 1] == 0x20) return false;
bytes1 lastChar = b[0];
for(uint i; i<b.length; i++){
bytes1 char = b[i];
if (char == 0x20 && lastChar == 0x20) return false;
if(
!(char >= 0x30 && char <= 0x39) &&
!(char >= 0x41 && char <= 0x5A) &&
!(char >= 0x61 && char <= 0x7A) &&
!(char == 0x20)
)
return false;
lastChar = char;
}
return true;
}
function toLower(string memory str) public pure returns (string memory){
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
bLower[i] = bytes1(uint8(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
function setOpenSeaProxyRegistry(OpenSeaProxyRegistry openSeaProxyRegistry_)
external
onlyOwner
{
openSeaProxyRegistry = openSeaProxyRegistry_;
}
function flipOpenSeaApproved() external onlyOwner {
isOpenSeaApproved = !isOpenSeaApproved;
}
function flipSaleState() external onlyOwner {
require(saleState < 3, "Sale state is already closed");
saleState++;
}
function setMaxSupply(uint256 _supply) public onlyOwner {
MAX = _supply;
}
function setFreeSupply(uint256 _supply) public onlyOwner {
MAX_FREE = _supply;
}
function setPrice(uint256 _newPrice) external onlyOwner {
PRICE = _newPrice;
}
function withdrawAll() public payable onlyOwner {
uint256 _share = address(this).balance / 100;
require(payable(t1).send(_share * 90));
require(payable(t2).send(_share * 10));
}
function isApprovedForAll(address _owner, address operator)
public
view
override
returns (bool)
{
return
(isOpenSeaApproved &&
address(openSeaProxyRegistry.proxies(_owner)) == operator) ||
super.isApprovedForAll(_owner, operator);
}
function isWhitelisted(address account_, bytes32[] calldata proof_)
public
view
returns (bool)
{
return _verify(_leaf(account_), proof_);
}
function setMerkleRoot(bytes32 merkleRoot_) public onlyOwner {
_merkleRoot = merkleRoot_;
}
function _leaf(address account_) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(account_));
}
function _verify(bytes32 leaf_, bytes32[] memory proof_)
internal
view
returns (bool)
{
return MerkleProof.verify(proof_, _merkleRoot, leaf_);
}
function setDescriptor(address source) external onlyOwner {
descriptor = InterfaceDescriptor(source);
}
function expand(uint256 _randomNumber, uint256 n)
private
pure
returns (uint16[] memory expandedValues)
{
expandedValues = new uint16[](n);
for (uint256 i = 0; i < n; i++) {
expandedValues[i] = bytes2uint(keccak256(abi.encode(_randomNumber, i)));
}
return expandedValues;
}
function bytes2uint(bytes32 _a) private pure returns (uint16) {
return uint16(uint256(_a));
}
function freeClaimedCount() external view returns (uint256) {
return freeClaimed;
}
function rerollsMadeCount() external view returns (uint256) {
return rerollsMade;
}
function addLegendaryNumber(uint256 _legendaryId) public onlyOwner {
legendaryList.push(_legendaryId);
}
function legendariesList() external view returns (uint256[] memory) {
return legendaryList;
}
function addNewLegendary(string memory _legendaryName) public onlyOwner {
traitsByName[8].push(_legendaryName);
}
function tokensOfOwner(address address_) public virtual view returns (uint256[] memory) {
uint256 _balance = balanceOf(address_);
uint256[] memory _tokens = new uint256[] (_balance);
uint256 _index;
uint256 _loopThrough = totalSupply();
for (uint256 i = 0; i < _loopThrough; i++) {
bool _exists = _exists(i);
if (_exists) {
if (ownerOf(i) == address_) { _tokens[_index] = i; _index++; }
}
else if (!_exists && _tokens[_balance - 1] == 0) { _loopThrough++; }
}
return _tokens;
}
function uint2str(uint256 _i)
internal
pure
returns (string memory _uintAsString)
{
if (_i == 0) {
return "0";
}
uint256 j = _i;
uint256 len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint256 k = len;
while (_i != 0) {
k = k - 1;
uint8 temp = (48 + uint8(_i - (_i / 10) * 10));
bytes1 b1 = bytes1(temp);
bstr[k] = b1;
_i /= 10;
}
return string(bstr);
}
string internal constant TABLE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
function base64(bytes memory data) internal pure returns (string memory) {
if (data.length == 0) return '';
string memory table = TABLE;
uint256 encodedLen = 4 * ((data.length + 2) / 3);
string memory result = new string(encodedLen + 32);
assembly {
mstore(result, encodedLen)
let tablePtr := add(table, 1)
let dataPtr := data
let endPtr := add(dataPtr, mload(data))
let resultPtr := add(result, 32)
for {} lt(dataPtr, endPtr) {}
{
dataPtr := add(dataPtr, 3)
let input := mload(dataPtr)
mstore(resultPtr, shl(248, mload(add(tablePtr, and(shr(18, input), 0x3F)))))
resultPtr := add(resultPtr, 1)
mstore(resultPtr, shl(248, mload(add(tablePtr, and(shr(12, input), 0x3F)))))
resultPtr := add(resultPtr, 1)
mstore(resultPtr, shl(248, mload(add(tablePtr, and(shr( 6, input), 0x3F)))))
resultPtr := add(resultPtr, 1)
mstore(resultPtr, shl(248, mload(add(tablePtr, and( input, 0x3F)))))
resultPtr := add(resultPtr, 1)
}
switch mod(mload(data), 3)
case 1 { mstore(sub(resultPtr, 2), shl(240, 0x3d3d)) }
case 2 { mstore(sub(resultPtr, 1), shl(248, 0x3d)) }
}
return result;
}
}
