Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: GPL-3.0

pragma solidity^0.8.0;

import "./ERC721A.sol";
import "./ERC721ABurnable.sol";
import "./Ownable.sol";
import "./ECDSA.sol";
import "./Strings.sol";
import "./SafeMath.sol";

contract Reef is ERC721A, ERC721ABurnable, Ownable {
    using ECDSA for bytes32; // allows us to convert bytes32 through series of casting to signature
    using Strings for uint256; // casting uint256 -> string
    using SafeMath for uint256;

    address private _signerAddress; // signer for the ECDSA addresses
    uint256 public maxSupply = 1111; // supply
    string private baseURI; // place our metadata is stored
    bool private mintAllowed = true; // in case wanting to stop mints 
    string private baseExtension = ".json"; // metadata file extension
    uint256 MAX_INT = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;

    // our config for sales
    struct Config {
        uint256 cost;
        uint256 maxPerTX;
        uint256 maxPerWallet;
        uint256 startTime;
    }
    // public sale config
    Config saleConfig = Config({ 
        cost: 0.08 ether,
        maxPerTX: 1,
        maxPerWallet: 1111, // unlimited (max size is 1111)
        startTime: 1653321600 
    });
    // whitelist sale config
    Config presaleConfig = Config({ 
        cost: 0.065 ether,
        maxPerTX: 1,
        maxPerWallet: 1,
        startTime: 1653318000 
    });
    // just a simple constructor
    constructor(string memory _name, string memory _symbol, address wlSigner) ERC721A(_name, _symbol){ 
        _signerAddress = wlSigner;
    }

    // This function should never be run
    // Only under the circumstance of inital signer being compromised 
    function changeSigner(address _newSigner) public onlyOwner {
        _signerAddress = _newSigner;
    }

    // other setters 
    function changeMaxSupply(uint256 _maxSupply) public onlyOwner {
        maxSupply = _maxSupply;
    }

    function changeBaseExtension(string memory _baseExtension) public onlyOwner {
        baseExtension = _baseExtension;
    }

    function changeBaseURI(string memory _baseURI) public onlyOwner {
        baseURI = _baseURI;
    }

    // config setters
    function changeFullConfig(uint256 _cost, uint256 _maxTx, uint256 _maxWallet, uint256 _startTime, bool editingSale) public onlyOwner {
        if (editingSale) {
            saleConfig = Config({
                cost: _cost,
                maxPerTX: _maxTx,
                maxPerWallet: _maxWallet,
                startTime: _startTime
            });
        } else {
            presaleConfig = Config({
                cost: _cost,
                maxPerTX: _maxTx,
                maxPerWallet: _maxWallet,
                startTime: _startTime
            });
        }

    }
    
    function changeSaleCost(uint256 _cost) public onlyOwner {
        saleConfig.cost = _cost;
    }

    function changeSaleMaxPerTx(uint256 _max) public onlyOwner {
        saleConfig.maxPerTX = _max;
    }

    function changeSaleMaxPerWallet(uint256 _max) public onlyOwner {
        saleConfig.maxPerWallet = _max;
    }

    function changeSaleStartTime(uint256 _start) public onlyOwner {
        saleConfig.startTime = _start;
    }


    function changePresaleCost(uint256 _cost) public onlyOwner {
        presaleConfig.cost = _cost;
    }

    function changePresaleMaxPerTx(uint256 _max) public onlyOwner {
        presaleConfig.maxPerTX = _max;
    }

    function changePresaleMaxPerWallet(uint256 _max) public onlyOwner {
        presaleConfig.maxPerWallet = _max;
    }

    function changePresaleStartTime(uint256 _start) public onlyOwner {
        presaleConfig.startTime = _start;
    }


    // config viewers 
    function viewPresaleCost() public view returns(uint256) {
        return presaleConfig.cost;
    }

    function viewPresaleMaxPerTx() public view returns(uint256){
        return presaleConfig.maxPerTX;
    }

    function viewPresaleMaxPerWallet() public view returns(uint256) {
        return presaleConfig.maxPerWallet;
    }

    function viewPresaleStartTime() public view returns(uint256) {
        return presaleConfig.startTime;
    }

    function viewSaleStart() public view returns(uint256) {
        return saleConfig.startTime;
    }
    
    function viewSaleCost() public view returns(uint256) {
        return saleConfig.cost;
    }

    function viewSaleMaxPerTx() public view returns(uint256){
        return saleConfig.maxPerTX;
    }

    function viewSaleMaxPerWallet() public view returns(uint256) {
        return saleConfig.maxPerWallet;
    }

    function whitelistMint(uint256 _quantity, bytes calldata signature) external payable{
        require(_quantity <= presaleConfig.maxPerTX, "This exceeds max per transaction");
        require(_quantity > 0, "You must mint more than 0");
        require(mintAllowed, "Mints are not currently allowed."); // in case admins want to close sale for any reason
        require(block.timestamp >= presaleConfig.startTime, "The sale is not live");
        require(msg.value * _quantity >= presaleConfig.cost, "User did not send enough ETH with transaction");
        require(totalSupply() +_quantity <= maxSupply, "We do not have enough supply for this"); // check we have enough supply for this
        require(_numberMinted(msg.sender) + _quantity <= presaleConfig.maxPerWallet, "This exceeds the amount you can mint in WL sale");
        // ECDSA magic :o
        require(_signerAddress == keccak256(
            abi.encodePacked(
                "\x19Ethereum Signed Message:\n32",
                bytes32(uint256(uint160(msg.sender)))
            )
        ).recover(signature), "Signer address mismatch.");
        // use erc721a for useful methods
        _safeMint(msg.sender, _quantity);
    }

    // simple mint function
    function mint(uint256 _quantity) external payable {
        require(_quantity <= saleConfig.maxPerTX, "This exceeds max per transaction");
        require(_quantity > 0, "You must mint more than 0");
        require(mintAllowed, "Mints are not currently allowed.");
        require(block.timestamp >= saleConfig.startTime, "The sale is not live");
        require(msg.value * _quantity >= saleConfig.cost, "User did not send enough ETH with transaction");
        require(totalSupply() +_quantity <= maxSupply);
        _safeMint(msg.sender, _quantity);
    }

    // check if user is on whitelist
    function testOnWl(bytes calldata signature) external view returns(bool) {
        require(_signerAddress == keccak256(
            abi.encodePacked(
                "\x19Ethereum Signed Message:\n32",
                bytes32(uint256(uint160(msg.sender)))
            )
        ).recover(signature), "Signer address mismatch.");
        return true;
    }

    // if this ever fails ill cry
    function _widthdraw(address _address, uint256 _amount) internal {
        (bool success, ) = _address.call{value: _amount}("");
        require(success, "Transfer failed.");
    }
    // a user can check if they have already claimed there WL NFT
    function userUsedWl(address user) public view returns(bool) {
        return _numberMinted(user) >= presaleConfig.maxPerWallet;
    }
    // locator

    function _baseURI() internal override virtual view returns(string memory) {
        return baseURI; // retrieve our baseURI
    }

    function tokenURI(uint256 tokenID) public view virtual override returns(string memory) {
        require(_exists(tokenID), "This token does not exist");
        string memory currBaseURI = _baseURI();
        return bytes(currBaseURI).length > 0 ? string(abi.encodePacked(currBaseURI, tokenID.toString(), baseExtension)):""; // for opensea and other places to find the data of our nft
    }
    // money money must be funny in a rich mans world
    function withdrawAll() public onlyOwner{
        uint256 balance = address(this).balance;
        require(balance >0, "There is nothing to transfer");
        _widthdraw(0xfA86599BBAc7e2B2A32922D575d38DA31E27Ca6F, balance.mul(5).div(100));
        _widthdraw(0xd56112A001E80033a3BC1e1Fa2BF4519de0E9694, address(this).balance);
    }
} 

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

import "../Strings.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

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

pragma solidity ^0.8.4;

import './IERC721A.sol';

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

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).
 *
 * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 *
 * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is IERC721A {
    // Mask of an entry in packed address data.
    uint256 private constant BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;

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

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

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

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

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

    // The bit mask of the `burned` bit in packed ownership.
    uint256 private constant BITMASK_BURNED = 1 << 224;
    
    // The bit position of the `nextInitialized` bit in packed ownership.
    uint256 private constant BITPOS_NEXT_INITIALIZED = 225;

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

    // The tokenId of the next token to be minted.
    uint256 private _currentIndex;

    // The number of tokens burned.
    uint256 private _burnCounter;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to ownership details
    // An empty struct value does not necessarily mean the token is unowned.
    // See `_packedOwnershipOf` implementation for details.
    //
    // Bits Layout:
    // - [0..159]   `addr`
    // - [160..223] `startTimestamp`
    // - [224]      `burned`
    // - [225]      `nextInitialized`
    mapping(uint256 => uint256) private _packedOwnerships;

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

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

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

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

    /**
     * @dev Returns the starting token ID. 
     * To change the starting token ID, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 0;
    }

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

    /**
     * @dev Returns the total number of tokens in existence.
     * Burned tokens will reduce the count. 
     * To get the total number of tokens minted, please see `_totalMinted`.
     */
    function totalSupply() public view override returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than `_currentIndex - _startTokenId()` times.
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

    /**
     * @dev Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view returns (uint256) {
        // Counter underflow is impossible as _currentIndex does not decrement,
        // and it is initialized to `_startTokenId()`
        unchecked {
            return _currentIndex - _startTokenId();
        }
    }

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

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        // The interface IDs are constants representing the first 4 bytes of the XOR of
        // all function selectors in the interface. See: https://eips.ethereum.org/EIPS/eip-165
        // e.g. `bytes4(i.functionA.selector ^ i.functionB.selector ^ ...)`
        return
            interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165.
            interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.
            interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return _packedAddressData[owner] & BITMASK_ADDRESS_DATA_ENTRY;
    }

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

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

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

    /**
     * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal {
        uint256 packed = _packedAddressData[owner];
        uint256 auxCasted;
        assembly { // Cast aux without masking.
            auxCasted := aux
        }
        packed = (packed & BITMASK_AUX_COMPLEMENT) | (auxCasted << BITPOS_AUX);
        _packedAddressData[owner] = packed;
    }

    /**
     * Returns the packed ownership data of `tokenId`.
     */
    function _packedOwnershipOf(uint256 tokenId) private view returns (uint256) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr)
                if (curr < _currentIndex) {
                    uint256 packed = _packedOwnerships[curr];
                    // If not burned.
                    if (packed & BITMASK_BURNED == 0) {
                        // Invariant:
                        // There will always be an ownership that has an address and is not burned
                        // before an ownership that does not have an address and is not burned.
                        // Hence, curr will not underflow.
                        //
                        // We can directly compare the packed value.
                        // If the address is zero, packed is zero.
                        while (packed == 0) {
                            packed = _packedOwnerships[--curr];
                        }
                        return packed;
                    }
                }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * Returns the unpacked `TokenOwnership` struct from `packed`.
     */
    function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
        ownership.addr = address(uint160(packed));
        ownership.startTimestamp = uint64(packed >> BITPOS_START_TIMESTAMP);
        ownership.burned = packed & BITMASK_BURNED != 0;
    }

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

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

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

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view override returns (address) {
        return address(uint160(_packedOwnershipOf(tokenId)));
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    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, _toString(tokenId))) : '';
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return '';
    }

    /**
     * @dev Casts the address to uint256 without masking.
     */
    function _addressToUint256(address value) private pure returns (uint256 result) {
        assembly {
            result := value
        }
    }

    /**
     * @dev Casts the boolean to uint256 without branching.
     */
    function _boolToUint256(bool value) private pure returns (uint256 result) {
        assembly {
            result := value
        }
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public override {
        address owner = address(uint160(_packedOwnershipOf(tokenId)));
        if (to == owner) revert ApprovalToCurrentOwner();

        if (_msgSenderERC721A() != owner)
            if (!isApprovedForAll(owner, _msgSenderERC721A())) {
                revert ApprovalCallerNotOwnerNorApproved();
            }

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

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        if (operator == _msgSenderERC721A()) revert ApproveToCaller();

        _operatorApprovals[_msgSenderERC721A()][operator] = approved;
        emit ApprovalForAll(_msgSenderERC721A(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, '');
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        _transfer(from, to, tokenId);
        if (to.code.length != 0)
            if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {
                revert TransferToNonERC721ReceiverImplementer();
            }
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        return
            _startTokenId() <= tokenId &&
            tokenId < _currentIndex && // If within bounds,
            _packedOwnerships[tokenId] & BITMASK_BURNED == 0; // and not burned.
    }

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

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement
     *   {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    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);

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the balance and number minted.
            _packedAddressData[to] += quantity * ((1 << BITPOS_NUMBER_MINTED) | 1);

            // Updates:
            // - `address` to the owner.
            // - `startTimestamp` to the timestamp of minting.
            // - `burned` to `false`.
            // - `nextInitialized` to `quantity == 1`.
            _packedOwnerships[startTokenId] =
                _addressToUint256(to) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                (_boolToUint256(quantity == 1) << BITPOS_NEXT_INITIALIZED);

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            if (to.code.length != 0) {
                do {
                    emit Transfer(address(0), to, updatedIndex);
                    if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (updatedIndex < end);
                // Reentrancy protection
                if (_currentIndex != startTokenId) revert();
            } else {
                do {
                    emit Transfer(address(0), to, updatedIndex++);
                } while (updatedIndex < end);
            }
            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    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);

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the balance and number minted.
            _packedAddressData[to] += quantity * ((1 << BITPOS_NUMBER_MINTED) | 1);

            // Updates:
            // - `address` to the owner.
            // - `startTimestamp` to the timestamp of minting.
            // - `burned` to `false`.
            // - `nextInitialized` to `quantity == 1`.
            _packedOwnerships[startTokenId] =
                _addressToUint256(to) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                (_boolToUint256(quantity == 1) << BITPOS_NEXT_INITIALIZED);

            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);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) private {
        uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

        if (address(uint160(prevOwnershipPacked)) != from) revert TransferFromIncorrectOwner();

        bool isApprovedOrOwner = (_msgSenderERC721A() == from ||
            isApprovedForAll(from, _msgSenderERC721A()) ||
            getApproved(tokenId) == _msgSenderERC721A());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

        // Clear approvals from the previous owner.
        delete _tokenApprovals[tokenId];

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            // We can directly increment and decrement the balances.
            --_packedAddressData[from]; // Updates: `balance -= 1`.
            ++_packedAddressData[to]; // Updates: `balance += 1`.

            // Updates:
            // - `address` to the next owner.
            // - `startTimestamp` to the timestamp of transfering.
            // - `burned` to `false`.
            // - `nextInitialized` to `true`.
            _packedOwnerships[tokenId] =
                _addressToUint256(to) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                BITMASK_NEXT_INITIALIZED;

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

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

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

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
        uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

        address from = address(uint160(prevOwnershipPacked));

        if (approvalCheck) {
            bool isApprovedOrOwner = (_msgSenderERC721A() == from ||
                isApprovedForAll(from, _msgSenderERC721A()) ||
                getApproved(tokenId) == _msgSenderERC721A());

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

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

        // Clear approvals from the previous owner.
        delete _tokenApprovals[tokenId];

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            // Updates:
            // - `balance -= 1`.
            // - `numberBurned += 1`.
            //
            // We can directly decrement the balance, and increment the number burned.
            // This is equivalent to `packed -= 1; packed += 1 << BITPOS_NUMBER_BURNED;`.
            _packedAddressData[from] += (1 << BITPOS_NUMBER_BURNED) - 1;

            // Updates:
            // - `address` to the last owner.
            // - `startTimestamp` to the timestamp of burning.
            // - `burned` to `true`.
            // - `nextInitialized` to `true`.
            _packedOwnerships[tokenId] =
                _addressToUint256(from) |
                (block.timestamp << BITPOS_START_TIMESTAMP) |
                BITMASK_BURNED | 
                BITMASK_NEXT_INITIALIZED;

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

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

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

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        try ERC721A__IERC721Receiver(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data) returns (
            bytes4 retval
        ) {
            return retval == ERC721A__IERC721Receiver(to).onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == 0) {
                revert TransferToNonERC721ReceiverImplementer();
            } else {
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     * And also called before burning one token.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
     * minting.
     * And also called after one token has been burned.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
     * transferred to `to`.
     * - When `from` is zero, `tokenId` has been minted for `to`.
     * - When `to` is zero, `tokenId` has been burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function _toString(uint256 value) internal pure returns (string memory ptr) {
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit), 
            // but we allocate 128 bytes to keep the free memory pointer 32-byte word aliged.
            // We will need 1 32-byte word to store the length, 
            // and 3 32-byte words to store a maximum of 78 digits. Total: 32 + 3 * 32 = 128.
            ptr := add(mload(0x40), 128)
            // Update the free memory pointer to allocate.
            mstore(0x40, ptr)

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

            // We write the string from the rightmost digit to the leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            // Costs a bit more than early returning for the zero case,
            // but cheaper in terms of deployment and overall runtime costs.
            for { 
                // Initialize and perform the first pass without check.
                let temp := value
                // Move the pointer 1 byte leftwards to point to an empty character slot.
                ptr := sub(ptr, 1)
                // Write the character to the pointer. 48 is the ASCII index of '0'.
                mstore8(ptr, add(48, mod(temp, 10)))
                temp := div(temp, 10)
            } temp { 
                // Keep dividing `temp` until zero.
                temp := div(temp, 10)
            } { // Body of the for loop.
                ptr := sub(ptr, 1)
                mstore8(ptr, add(48, mod(temp, 10)))
            }
            
            let length := sub(end, ptr)
            // Move the pointer 32 bytes leftwards to make room for the length.
            ptr := sub(ptr, 32)
            // Store the length.
            mstore(ptr, length)
        }
    }
}

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

pragma solidity ^0.8.4;

import './IERC721ABurnable.sol';
import './ERC721A.sol';

/**
 * @title ERC721A Burnable Token
 * @dev ERC721A Token that can be irreversibly burned (destroyed).
 */
abstract contract ERC721ABurnable is ERC721A, IERC721ABurnable {
    /**
     * @dev Burns `tokenId`. See {ERC721A-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) public virtual override {
        _burn(tokenId, true);
    }
}

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

pragma solidity ^0.8.4;

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

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

    /**
     * The caller cannot approve to their own address.
     */
    error ApproveToCaller();

    /**
     * The caller cannot approve to the current owner.
     */
    error ApprovalToCurrentOwner();

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

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

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

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

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

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

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

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

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

    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Keeps track of the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
    }

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     *
     * Burned tokens are calculated here, use `_totalMinted()` if you want to count just minted tokens.
     */
    function totalSupply() external view returns (uint256);

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

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

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

    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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

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

    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

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

pragma solidity ^0.8.4;

import '../IERC721A.sol';

/**
 * @dev Interface of an ERC721ABurnable compliant contract.
 */
interface IERC721ABurnable is IERC721A {
    /**
     * @dev Burns `tokenId`. See {ERC721A-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;

import "./Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        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);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    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);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed 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);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"wlSigner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","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":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseExtension","type":"string"}],"name":"changeBaseExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseURI","type":"string"}],"name":"changeBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_cost","type":"uint256"},{"internalType":"uint256","name":"_maxTx","type":"uint256"},{"internalType":"uint256","name":"_maxWallet","type":"uint256"},{"internalType":"uint256","name":"_startTime","type":"uint256"},{"internalType":"bool","name":"editingSale","type":"bool"}],"name":"changeFullConfig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxSupply","type":"uint256"}],"name":"changeMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_cost","type":"uint256"}],"name":"changePresaleCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_max","type":"uint256"}],"name":"changePresaleMaxPerTx","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_max","type":"uint256"}],"name":"changePresaleMaxPerWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_start","type":"uint256"}],"name":"changePresaleStartTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_cost","type":"uint256"}],"name":"changeSaleCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_max","type":"uint256"}],"name":"changeSaleMaxPerTx","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_max","type":"uint256"}],"name":"changeSaleMaxPerWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_start","type":"uint256"}],"name":"changeSaleStartTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newSigner","type":"address"}],"name":"changeSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_quantity","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","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":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","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":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"testOnWl","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"totalSupply","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":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"userUsedWl","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"viewPresaleCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"viewPresaleMaxPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"viewPresaleMaxPerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"viewPresaleStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"viewSaleCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"viewSaleMaxPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"viewSaleMaxPerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"viewSaleStart","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_quantity","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000008eef9aacd7a3eebc5c1a7a4b0582163ed5d14fa7000000000000000000000000000000000000000000000000000000000000000a5245454620544f4b454e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000045245454600000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): REEF TOKEN
Arg [1] : _symbol (string): REEF
Arg [2] : wlSigner (address): 0x8eEf9aAcD7A3Eebc5c1a7a4B0582163eD5d14Fa7

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 0000000000000000000000008eef9aacd7a3eebc5c1a7a4b0582163ed5d14fa7
Arg [3] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [4] : 5245454620544f4b454e00000000000000000000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [6] : 5245454600000000000000000000000000000000000000000000000000000000

224:8142:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5031:615:2;;;;;;;;;;-1:-1:-1;5031:615:2;;;;;:::i;:::-;;:::i;:::-;;;9379:14:10;;9372:22;9354:41;;9342:2;9327:18;5031:615:2;;;;;;;;10044:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;12112:204::-;;;;;;;;;;-1:-1:-1;12112:204:2;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;8631:55:10;;;8613:74;;8601:2;8586:18;12112:204:2;8467:226:10;11572:474:2;;;;;;;;;;-1:-1:-1;11572:474:2;;;;;:::i;:::-;;:::i;:::-;;3220:110:6;;;;;;;;;;-1:-1:-1;3220:110:6;;;;;:::i;:::-;;:::i;4311:100::-;;;;;;;;;;-1:-1:-1;4383:20:6;;4311:100;;;16536:25:10;;;16524:2;16509:18;4311:100:6;16390:177:10;4085:315:2;;;;;;;;;;-1:-1:-1;4351:12:2;;4138:7;4335:13;:28;4085:315;;2988:104:6;;;;;;;;;;-1:-1:-1;2988:104:6;;;;;:::i;:::-;;:::i;4069:116::-;;;;;;;;;;-1:-1:-1;4151:26:6;;4069:116;;12998:170:2;;;;;;;;;;-1:-1:-1;12998:170:2;;;;;:::i;:::-;;:::i;4423:94:6:-;;;;;;;;;;-1:-1:-1;4494:10:6;:15;4423:94;;2005:125;;;;;;;;;;-1:-1:-1;2005:125:6;;;;;:::i;:::-;;:::i;2138:101::-;;;;;;;;;;-1:-1:-1;2138:101:6;;;;;:::i;:::-;;:::i;1894:103::-;;;;;;;;;;-1:-1:-1;1894:103:6;;;;;:::i;:::-;;:::i;13239:185:2:-;;;;;;;;;;-1:-1:-1;13239:185:2;;;;;:::i;:::-;;:::i;533:94:3:-;;;;;;;;;;-1:-1:-1;533:94:3;;;;;:::i;:::-;;:::i;3100:112:6:-;;;;;;;;;;-1:-1:-1;3100:112:6;;;;;:::i;:::-;;:::i;3696:116::-;;;;;;;;;;-1:-1:-1;3696:116:6;;;;;:::i;:::-;;:::i;2882:98::-;;;;;;;;;;-1:-1:-1;2882:98:6;;;;;:::i;:::-;;:::i;9833:144:2:-;;;;;;;;;;-1:-1:-1;9833:144:2;;;;;:::i;:::-;;:::i;6613:362:6:-;;;;;;;;;;-1:-1:-1;6613:362:6;;;;;:::i;:::-;;:::i;5710:224:2:-;;;;;;;;;;-1:-1:-1;5710:224:2;;;;;:::i;:::-;;:::i;1714:103:7:-;;;;;;;;;;;;;:::i;4525:101:6:-;;;;;;;;;;-1:-1:-1;4599:19:6;;4525:101;;3846:100;;;;;;;;;;-1:-1:-1;3920:13:6;:18;3846:100;;8026:337;;;;;;;;;;;;;:::i;7273:135::-;;;;;;;;;;-1:-1:-1;7273:135:6;;;;;:::i;:::-;7374:26;;-1:-1:-1;;;;;6105:25:2;;;;7327:4:6;6105:25:2;;;:18;:25;;1186:2;6105:25;;;;;:49;;1049:13;6104:80;7351:49:6;;;7273:135;1063:87:7;;;;;;;;;;-1:-1:-1;1136:6:7;;-1:-1:-1;;;;;1136:6:7;1063:87;;3452:110:6;;;;;;;;;;-1:-1:-1;3452:110:6;;;;;:::i;:::-;;:::i;10213:104:2:-;;;;;;;;;;;;;:::i;4752:1211:6:-;;;;;;:::i;:::-;;:::i;6000:567::-;;;;;;:::i;:::-;;:::i;12388:308:2:-;;;;;;;;;;-1:-1:-1;12388:308:2;;;;;:::i;:::-;;:::i;1758:105:6:-;;;;;;;;;;-1:-1:-1;1758:105:6;;;;;:::i;:::-;;:::i;13495:396:2:-;;;;;;;;;;-1:-1:-1;13495:396:2;;;;;:::i;:::-;;:::i;4634:110:6:-;;;;;;;;;;-1:-1:-1;4713:23:6;;4634:110;;3340:104;;;;;;;;;;-1:-1:-1;3340:104:6;;;;;:::i;:::-;;:::i;7571:394::-;;;;;;;;;;-1:-1:-1;7571:394:6;;;;;:::i;:::-;;:::i;3570:118::-;;;;;;;;;;-1:-1:-1;3570:118:6;;;;;:::i;:::-;;:::i;550:31::-;;;;;;;;;;;;;;;;4193:110;;;;;;;;;;-1:-1:-1;4272:23:6;;4193:110;;3954:107;;;;;;;;;;-1:-1:-1;4031:22:6;;3954:107;;12767:164:2;;;;;;;;;;-1:-1:-1;12767:164:2;;;;;:::i;:::-;-1:-1:-1;;;;;12888:25:2;;;12864:4;12888:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;12767:164;1972:201:7;;;;;;;;;;-1:-1:-1;1972:201:7;;;;;:::i;:::-;;:::i;2270:600:6:-;;;;;;;;;;-1:-1:-1;2270:600:6;;;;;:::i;:::-;;:::i;5031:615:2:-;5116:4;5416:25;;;;;;:102;;-1:-1:-1;5493:25:2;;;;;5416:102;:179;;;-1:-1:-1;5570:25:2;;;;;5416:179;5396:199;5031:615;-1:-1:-1;;5031:615:2:o;10044:100::-;10098:13;10131:5;10124:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10044:100;:::o;12112:204::-;12180:7;12205:16;12213:7;12205;:16::i;:::-;12200:64;;12230:34;;;;;;;;;;;;;;12200:64;-1:-1:-1;12284:24:2;;;;:15;:24;;;;;;-1:-1:-1;;;;;12284:24:2;;12112:204::o;11572:474::-;11645:13;11677:27;11696:7;11677:18;:27::i;:::-;11645:61;;11727:5;-1:-1:-1;;;;;11721:11:2;:2;-1:-1:-1;;;;;11721:11:2;;11717:48;;;11741:24;;;;;;;;;;;;;;11717:48;28215:10;-1:-1:-1;;;;;11782:28:2;;;11778:175;;11830:44;11847:5;28215:10;12767:164;:::i;11830:44::-;11825:128;;11902:35;;;;;;;;;;;;;;11825:128;11965:24;;;;:15;:24;;;;;;:29;;;;-1:-1:-1;;;;;11965:29:2;;;;;;;;;12010:28;;11965:24;;12010:28;;;;;;;11634:412;11572:474;;:::o;3220:110:6:-;1136:6:7;;-1:-1:-1;;;;;1136:6:7;28215:10:2;1283:23:7;1275:68;;;;-1:-1:-1;;;1275:68:7;;15066:2:10;1275:68:7;;;15048:21:10;;;15085:18;;;15078:30;15144:34;15124:18;;;15117:62;15196:18;;1275:68:7;;;;;;;;;3293:20:6;:29;3220:110::o;2988:104::-;1136:6:7;;-1:-1:-1;;;;;1136:6:7;28215:10:2;1283:23:7;1275:68;;;;-1:-1:-1;;;1275:68:7;;15066:2:10;1275:68:7;;;15048:21:10;;;15085:18;;;15078:30;15144:34;15124:18;;;15117:62;15196:18;;1275:68:7;14864:356:10;1275:68:7;3058:19:6;:26;2988:104::o;12998:170:2:-;13132:28;13142:4;13148:2;13152:7;13132:9;:28::i;:::-;12998:170;;;:::o;2005:125:6:-;1136:6:7;;-1:-1:-1;;;;;1136:6:7;28215:10:2;1283:23:7;1275:68;;;;-1:-1:-1;;;1275:68:7;;15066:2:10;1275:68:7;;;15048:21:10;;;15085:18;;;15078:30;15144:34;15124:18;;;15117:62;15196:18;;1275:68:7;14864:356:10;1275:68:7;2092:30:6;;::::1;::::0;:13:::1;::::0;:30:::1;::::0;::::1;::::0;::::1;:::i;:::-;;2005:125:::0;:::o;2138:101::-;1136:6:7;;-1:-1:-1;;;;;1136:6:7;28215:10:2;1283:23:7;1275:68;;;;-1:-1:-1;;;1275:68:7;;15066:2:10;1275:68:7;;;15048:21:10;;;15085:18;;;15078:30;15144:34;15124:18;;;15117:62;15196:18;;1275:68:7;14864:356:10;1275:68:7;2213:18:6;;::::1;::::0;:7:::1;::::0;:18:::1;::::0;::::1;::::0;::::1;:::i;1894:103::-:0;1136:6:7;;-1:-1:-1;;;;;1136:6:7;28215:10:2;1283:23:7;1275:68;;;;-1:-1:-1;;;1275:68:7;;15066:2:10;1275:68:7;;;15048:21:10;;;15085:18;;;15078:30;15144:34;15124:18;;;15117:62;15196:18;;1275:68:7;14864:356:10;1275:68:7;1967:9:6::1;:22:::0;1894:103::o;13239:185:2:-;13377:39;13394:4;13400:2;13404:7;13377:39;;;;;;;;;;;;:16;:39::i;533:94:3:-;599:20;605:7;614:4;599:5;:20::i;:::-;533:94;:::o;3100:112:6:-;1136:6:7;;-1:-1:-1;;;;;1136:6:7;28215:10:2;1283:23:7;1275:68;;;;-1:-1:-1;;;1275:68:7;;15066:2:10;1275:68:7;;;15048:21:10;;;15085:18;;;15078:30;15144:34;15124:18;;;15117:62;15196:18;;1275:68:7;14864:356:10;1275:68:7;3174:23:6;:30;3100:112::o;3696:116::-;1136:6:7;;-1:-1:-1;;;;;1136:6:7;28215:10:2;1283:23:7;1275:68;;;;-1:-1:-1;;;1275:68:7;;15066:2:10;1275:68:7;;;15048:21:10;;;15085:18;;;15078:30;15144:34;15124:18;;;15117:62;15196:18;;1275:68:7;14864:356:10;1275:68:7;3772:23:6;:32;3696:116::o;2882:98::-;1136:6:7;;-1:-1:-1;;;;;1136:6:7;28215:10:2;1283:23:7;1275:68;;;;-1:-1:-1;;;1275:68:7;;15066:2:10;1275:68:7;;;15048:21:10;;;15085:18;;;15078:30;15144:34;15124:18;;;15117:62;15196:18;;1275:68:7;14864:356:10;1275:68:7;2949:10:6::1;:23:::0;2882:98::o;9833:144:2:-;9897:7;9940:27;9959:7;9940:18;:27::i;6613:362:6:-;6679:4;6722:194;6906:9;;6722:194;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;6746:140:6;;8114:66:10;6746:140:6;;;8102:79:10;6858:10:6;8197:12:10;;;8190:28;8234:12;;;-1:-1:-1;6746:140:6;;-1:-1:-1;7872:380:10;6746:140:6;;;;;;;;;;;;;6722:175;;;;;;:183;;:194;;;;:::i;:::-;6704:14;;-1:-1:-1;;;;;6704:14:6;;;:212;;;6696:249;;;;-1:-1:-1;;;6696:249:6;;11294:2:10;6696:249:6;;;11276:21:10;11333:2;11313:18;;;11306:30;11372:26;11352:18;;;11345:54;11416:18;;6696:249:6;11092:348:10;6696:249:6;-1:-1:-1;6963:4:6;6613:362;;;;:::o;5710:224:2:-;5774:7;-1:-1:-1;;;;;5798:19:2;;5794:60;;5826:28;;;;;;;;;;;;;;5794:60;-1:-1:-1;;;;;;5872:25:2;;;;;:18;:25;;;;;;1049:13;5872:54;;5710:224::o;1714:103:7:-;1136:6;;-1:-1:-1;;;;;1136:6:7;28215:10:2;1283:23:7;1275:68;;;;-1:-1:-1;;;1275:68:7;;15066:2:10;1275:68:7;;;15048:21:10;;;15085:18;;;15078:30;15144:34;15124:18;;;15117:62;15196:18;;1275:68:7;14864:356:10;1275:68:7;1779:30:::1;1806:1;1779:18;:30::i;:::-;1714:103::o:0;8026:337:6:-;1136:6:7;;-1:-1:-1;;;;;1136:6:7;28215:10:2;1283:23:7;1275:68;;;;-1:-1:-1;;;1275:68:7;;15066:2:10;1275:68:7;;;15048:21:10;;;15085:18;;;15078:30;15144:34;15124:18;;;15117:62;15196:18;;1275:68:7;14864:356:10;1275:68:7;8094:21:6::1;8134:10:::0;8126:51:::1;;;::::0;-1:-1:-1;;;8126:51:6;;10937:2:10;8126:51:6::1;::::0;::::1;10919:21:10::0;10976:2;10956:18;;;10949:30;11015;10995:18;;;10988:58;11063:18;;8126:51:6::1;10735:352:10::0;8126:51:6::1;8188:79;8199:42;8243:23;8262:3;8243:14;:7:::0;8255:1:::1;8243:11;:14::i;:::-;:18:::0;::::1;:23::i;:::-;8188:10;:79::i;:::-;8278:77;8289:42;8333:21;8278:10;:77::i;3452:110::-:0;1136:6:7;;-1:-1:-1;;;;;1136:6:7;28215:10:2;1283:23:7;1275:68;;;;-1:-1:-1;;;1275:68:7;;15066:2:10;1275:68:7;;;15048:21:10;;;15085:18;;;15078:30;15144:34;15124:18;;;15117:62;15196:18;;1275:68:7;14864:356:10;1275:68:7;3525:22:6;:29;3452:110::o;10213:104:2:-;10269:13;10302:7;10295:14;;;;;:::i;4752:1211:6:-;4868:22;;4855:35;;;4847:80;;;;-1:-1:-1;;;4847:80:6;;11647:2:10;4847:80:6;;;11629:21:10;;;11666:18;;;11659:30;11725:34;11705:18;;;11698:62;11777:18;;4847:80:6;11445:356:10;4847:80:6;4958:1;4946:9;:13;4938:51;;;;-1:-1:-1;;;4938:51:6;;13594:2:10;4938:51:6;;;13576:21:10;13633:2;13613:18;;;13606:30;13672:27;13652:18;;;13645:55;13717:18;;4938:51:6;13392:349:10;4938:51:6;5008:11;;;;5000:56;;;;-1:-1:-1;;;5000:56:6;;14302:2:10;5000:56:6;;;14284:21:10;;;14321:18;;;14314:30;14380:34;14360:18;;;14353:62;14432:18;;5000:56:6;14100:356:10;5000:56:6;5146:23;;5127:15;:42;;5119:75;;;;-1:-1:-1;;;5119:75:6;;10588:2:10;5119:75:6;;;10570:21:10;10627:2;10607:18;;;10600:30;10666:22;10646:18;;;10639:50;10706:18;;5119:75:6;10386:344:10;5119:75:6;5238:13;:18;5213:21;5225:9;5213;:21;:::i;:::-;:43;;5205:101;;;;-1:-1:-1;;;5205:101:6;;15427:2:10;5205:101:6;;;15409:21:10;15466:2;15446:18;;;15439:30;15505:34;15485:18;;;15478:62;15576:15;15556:18;;;15549:43;15609:19;;5205:101:6;15225:409:10;5205:101:6;5353:9;;5340;5325:13;4351:12:2;;4138:7;4335:13;:28;;4085:315;5325:13:6;:24;;;;:::i;:::-;:37;;5317:87;;;;-1:-1:-1;;;5317:87:6;;16186:2:10;5317:87:6;;;16168:21:10;16225:2;16205:18;;;16198:30;16264:34;16244:18;;;16237:62;16335:7;16315:18;;;16308:35;16360:19;;5317:87:6;15984:401:10;5317:87:6;5504:26;;5477:10;6077:7:2;6105:25;;;:18;:25;;1186:2;6105:25;;;;;5491:9:6;;6105:49:2;1049:13;6104:80;5463:37:6;;;;:::i;:::-;:67;;5455:127;;;;-1:-1:-1;;;5455:127:6;;13178:2:10;5455:127:6;;;13160:21:10;13217:2;13197:18;;;13190:30;13256:34;13236:18;;;13229:62;13327:17;13307:18;;;13300:45;13362:19;;5455:127:6;12976:411:10;5455:127:6;5646:194;5830:9;;5646:194;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;5670:140:6;;8114:66:10;5670:140:6;;;8102:79:10;5782:10:6;8197:12:10;;;8190:28;8234:12;;;-1:-1:-1;5670:140:6;;-1:-1:-1;7872:380:10;5646:194:6;5628:14;;-1:-1:-1;;;;;5628:14:6;;;:212;;;5620:249;;;;-1:-1:-1;;;5620:249:6;;11294:2:10;5620:249:6;;;11276:21:10;11333:2;11313:18;;;11306:30;11372:26;11352:18;;;11345:54;11416:18;;5620:249:6;11092:348:10;5620:249:6;5923:32;5933:10;5945:9;5923;:32::i;6000:567::-;6082:19;;6069:32;;;6061:77;;;;-1:-1:-1;;;6061:77:6;;11647:2:10;6061:77:6;;;11629:21:10;;;11666:18;;;11659:30;11725:34;11705:18;;;11698:62;11777:18;;6061:77:6;11445:356:10;6061:77:6;6169:1;6157:9;:13;6149:51;;;;-1:-1:-1;;;6149:51:6;;13594:2:10;6149:51:6;;;13576:21:10;13633:2;13613:18;;;13606:30;13672:27;13652:18;;;13645:55;13717:18;;6149:51:6;13392:349:10;6149:51:6;6219:11;;;;6211:56;;;;-1:-1:-1;;;6211:56:6;;14302:2:10;6211:56:6;;;14284:21:10;;;14321:18;;;14314:30;14380:34;14360:18;;;14353:62;14432:18;;6211:56:6;14100:356:10;6211:56:6;6305:20;;6286:15;:39;;6278:72;;;;-1:-1:-1;;;6278:72:6;;10588:2:10;6278:72:6;;;10570:21:10;10627:2;10607:18;;;10600:30;10666:22;10646:18;;;10639:50;10706:18;;6278:72:6;10386:344:10;6278:72:6;6394:10;:15;6369:21;6381:9;6369;:21;:::i;:::-;:40;;6361:98;;;;-1:-1:-1;;;6361:98:6;;15427:2:10;6361:98:6;;;15409:21:10;15466:2;15446:18;;;15439:30;15505:34;15485:18;;;15478:62;15576:15;15556:18;;;15549:43;15609:19;;6361:98:6;15225:409:10;6361:98:6;6506:9;;6493;6478:13;4351:12:2;;4138:7;4335:13;:28;;4085:315;6478:13:6;:24;;;;:::i;:::-;:37;;6470:46;;;;;;6527:32;6537:10;6549:9;6527;:32::i;12388:308:2:-;-1:-1:-1;;;;;12487:31:2;;28215:10;12487:31;12483:61;;;12527:17;;;;;;;;;;;;;;12483:61;28215:10;12557:39;;;;:18;:39;;;;;;;;-1:-1:-1;;;;;12557:49:2;;;;;;;;;;;;:60;;;;;;;;;;;;;12633:55;;9354:41:10;;;12557:49:2;;28215:10;12633:55;;9327:18:10;12633:55:2;;;;;;;12388:308;;:::o;1758:105:6:-;1136:6:7;;-1:-1:-1;;;;;1136:6:7;28215:10:2;1283:23:7;1275:68;;;;-1:-1:-1;;;1275:68:7;;15066:2:10;1275:68:7;;;15048:21:10;;;15085:18;;;15078:30;15144:34;15124:18;;;15117:62;15196:18;;1275:68:7;14864:356:10;1275:68:7;1828:14:6::1;:27:::0;;;::::1;-1:-1:-1::0;;;;;1828:27:6;;;::::1;::::0;;;::::1;::::0;;1758:105::o;13495:396:2:-;13662:28;13672:4;13678:2;13682:7;13662:9;:28::i;:::-;-1:-1:-1;;;;;13705:14:2;;;:19;13701:183;;13744:56;13775:4;13781:2;13785:7;13794:5;13744:30;:56::i;:::-;13739:145;;13828:40;;;;;;;;;;;;;;13739:145;13495:396;;;;:::o;3340:104:6:-;1136:6:7;;-1:-1:-1;;;;;1136:6:7;28215:10:2;1283:23:7;1275:68;;;;-1:-1:-1;;;1275:68:7;;15066:2:10;1275:68:7;;;15048:21:10;;;15085:18;;;15078:30;15144:34;15124:18;;;15117:62;15196:18;;1275:68:7;14864:356:10;1275:68:7;3410:13:6::1;:26:::0;3340:104::o;7571:394::-;7643:13;7677:16;7685:7;7677;:16::i;:::-;7669:54;;;;-1:-1:-1;;;7669:54:6;;13948:2:10;7669:54:6;;;13930:21:10;13987:2;13967:18;;;13960:30;14026:27;14006:18;;;13999:55;14071:18;;7669:54:6;13746:349:10;7669:54:6;7734:25;7762:10;:8;:10::i;:::-;7734:38;;7818:1;7796:11;7790:25;:29;:107;;;;;;;;;;;;;;;;;7846:11;7859:18;:7;:16;:18::i;:::-;7879:13;7829:64;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;7790:107;7783:114;7571:394;-1:-1:-1;;;7571:394:6:o;3570:118::-;1136:6:7;;-1:-1:-1;;;;;1136:6:7;28215:10:2;1283:23:7;1275:68;;;;-1:-1:-1;;;1275:68:7;;15066:2:10;1275:68:7;;;15048:21:10;;;15085:18;;;15078:30;15144:34;15124:18;;;15117:62;15196:18;;1275:68:7;14864:356:10;1275:68:7;3647:26:6;:33;3570:118::o;1972:201:7:-;1136:6;;-1:-1:-1;;;;;1136:6:7;28215:10:2;1283:23:7;1275:68;;;;-1:-1:-1;;;1275:68:7;;15066:2:10;1275:68:7;;;15048:21:10;;;15085:18;;;15078:30;15144:34;15124:18;;;15117:62;15196:18;;1275:68:7;14864:356:10;1275:68:7;-1:-1:-1;;;;;2061:22:7;::::1;2053:73;;;::::0;-1:-1:-1;;;2053:73:7;;12368:2:10;2053:73:7::1;::::0;::::1;12350:21:10::0;12407:2;12387:18;;;12380:30;12446:34;12426:18;;;12419:62;12517:8;12497:18;;;12490:36;12543:19;;2053:73:7::1;12166:402:10::0;2053:73:7::1;2137:28;2156:8;2137:18;:28::i;2270:600:6:-:0;1136:6:7;;-1:-1:-1;;;;;1136:6:7;28215:10:2;1283:23:7;1275:68;;;;-1:-1:-1;;;1275:68:7;;15066:2:10;1275:68:7;;;15048:21:10;;;15085:18;;;15078:30;15144:34;15124:18;;;15117:62;15196:18;;1275:68:7;14864:356:10;1275:68:7;2417:11:6::1;2413:448;;;2458:171;::::0;;::::1;::::0;::::1;::::0;;;;;::::1;::::0;::::1;::::0;;;;;;;;;;;;;;2445:10:::1;:184:::0;;;;;;;;;;;;;;;2413:448:::1;;;2678:171;::::0;;::::1;::::0;::::1;::::0;;;;;::::1;::::0;::::1;::::0;;;;;;;;;;;;;;2662:13:::1;:187:::0;;;;;;;;;;;;;;;2413:448:::1;2270:600:::0;;;;;:::o;14146:273:2:-;14203:4;14293:13;;14283:7;:23;14240:152;;;;-1:-1:-1;;14344:26:2;;;;:17;:26;;;;;;1819:8;14344:43;:48;;14146:273::o;7348:1129::-;7415:7;7450;7552:13;;7545:4;:20;7541:869;;;7590:14;7607:23;;;:17;:23;;;;;;1819:8;7696:23;;7692:699;;8215:113;8222:11;8215:113;;-1:-1:-1;8293:6:2;;8275:25;;;;:17;:25;;;;;;8215:113;;7692:699;7567:843;7541:869;8438:31;;;;;;;;;;;;;;19385:2515;19500:27;19530;19549:7;19530:18;:27::i;:::-;19500:57;;19615:4;-1:-1:-1;;;;;19574:45:2;19590:19;-1:-1:-1;;;;;19574:45:2;;19570:86;;19628:28;;;;;;;;;;;;;;19570:86;19669:22;28215:10;-1:-1:-1;;;;;19695:27:2;;;;:87;;-1:-1:-1;19739:43:2;19756:4;28215:10;12767:164;:::i;19739:43::-;19695:147;;;-1:-1:-1;28215:10:2;19799:20;19811:7;19799:11;:20::i;:::-;-1:-1:-1;;;;;19799:43:2;;19695:147;19669:174;;19861:17;19856:66;;19887:35;;;;;;;;;;;;;;19856:66;-1:-1:-1;;;;;19937:16:2;;19933:52;;19962:23;;;;;;;;;;;;;;19933:52;20114:24;;;;:15;:24;;;;;;;;20107:31;;;;;;-1:-1:-1;;;;;20506:24:2;;;;;:18;:24;;;;;20504:26;;;;;;20575:22;;;;;;;20573:24;;-1:-1:-1;20573:24:2;;;20868:26;;;:17;:26;;;;;2101:8;20956:15;1703:3;20956:41;20914:84;;:128;;20868:174;;;21162:46;;21158:626;;21266:1;21256:11;;21234:19;21389:30;;;:17;:30;;;;;;21385:384;;21527:13;;21512:11;:28;21508:242;;21674:30;;;;:17;:30;;;;;:52;;;21508:242;21215:569;21158:626;21831:7;21827:2;-1:-1:-1;;;;;21812:27:2;21821:4;-1:-1:-1;;;;;21812:27:2;;;;;;;;;;;21850:42;13495:396;22296:2809;22376:27;22406;22425:7;22406:18;:27::i;:::-;22376:57;-1:-1:-1;22376:57:2;22511:311;;;;22545:22;28215:10;-1:-1:-1;;;;;22571:27:2;;;;:91;;-1:-1:-1;22619:43:2;22636:4;28215:10;12767:164;:::i;22619:43::-;22571:155;;;-1:-1:-1;28215:10:2;22683:20;22695:7;22683:11;:20::i;:::-;-1:-1:-1;;;;;22683:43:2;;22571:155;22545:182;;22749:17;22744:66;;22775:35;;;;;;;;;;;;;;22744:66;22530:292;22511:311;22958:24;;;;:15;:24;;;;;;;;22951:31;;;;;;-1:-1:-1;;;;;23571:24:2;;;;:18;:24;;;;;:59;;23599:31;23571:59;;;23868:26;;;:17;:26;;;;;23914:165;23958:15;1703:3;23958:41;23914:86;;:165;23868:211;;2101:8;24199:46;;24195:626;;24303:1;24293:11;;24271:19;24426:30;;;:17;:30;;;;;;24422:384;;24564:13;;24549:11;:28;24545:242;;24711:30;;;;:17;:30;;;;;:52;;;24545:242;24252:569;24195:626;24849:35;;24876:7;;24872:1;;-1:-1:-1;;;;;24849:35:2;;;;;24872:1;;24849:35;-1:-1:-1;;25072:12:2;:14;;;;;;-1:-1:-1;;22296:2809:2:o;4505:231:1:-;4583:7;4604:17;4623:18;4645:27;4656:4;4662:9;4645:10;:27::i;:::-;4603:69;;;;4683:18;4695:5;4683:11;:18::i;:::-;-1:-1:-1;4719:9:1;4505:231;-1:-1:-1;;;4505:231:1:o;2333:191:7:-;2426:6;;;-1:-1:-1;;;;;2443:17:7;;;;;;;;;;;2476:40;;2426:6;;;2443:17;2426:6;;2476:40;;2407:16;;2476:40;2396:128;2333:191;:::o;3585:98:8:-;3643:7;3670:5;3674:1;3670;:5;:::i;3984:98::-;4042:7;4069:5;4073:1;4069;:5;:::i;7018:182:6:-;7094:12;7112:8;-1:-1:-1;;;;;7112:13:6;7133:7;7112:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7093:52;;;7164:7;7156:36;;;;-1:-1:-1;;;7156:36:6;;15841:2:10;7156:36:6;;;15823:21:10;15880:2;15860:18;;;15853:30;15919:18;15899;;;15892:46;15955:18;;7156:36:6;15639:340:10;14503:104:2;14572:27;14582:2;14586:8;14572:27;;;;;;;;;;;;:9;:27::i;25597:716::-;25781:88;;;;;25760:4;;-1:-1:-1;;;;;25781:45:2;;;;;:88;;28215:10;;25848:4;;25854:7;;25863:5;;25781:88;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;25781:88:2;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;25777:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;26064:13:2;;26060:235;;26110:40;;;;;;;;;;;;;;26060:235;26253:6;26247:13;26238:6;26234:2;26230:15;26223:38;25777:529;25940:64;;25950:54;25940:64;;-1:-1:-1;25777:529:2;25597:716;;;;;;:::o;7432:131:6:-;7491:13;7524:7;7517:14;;;;;:::i;392:723:9:-;448:13;669:10;665:53;;-1:-1:-1;;696:10:9;;;;;;;;;;;;;;;;;;392:723::o;665:53::-;743:5;728:12;784:78;791:9;;784:78;;817:8;;;;:::i;:::-;;-1:-1:-1;840:10:9;;-1:-1:-1;848:2:9;840:10;;:::i;:::-;;;784:78;;;872:19;904:6;894:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;894:17:9;;872:39;;922:154;929:10;;922:154;;956:11;966:1;956:11;;:::i;:::-;;-1:-1:-1;1025:10:9;1033:2;1025:5;:10;:::i;:::-;1012:24;;:2;:24;:::i;:::-;999:39;;982:6;989;982:14;;;;;;;;:::i;:::-;;;;:56;;;;;;;;;;-1:-1:-1;1053:11:9;1062:2;1053:11;;:::i;:::-;;;922:154;;2299:1404:1;2380:7;2389:12;2614:9;:16;2634:2;2614:22;2610:1086;;;2958:4;2943:20;;2937:27;3008:4;2993:20;;2987:27;3066:4;3051:20;;3045:27;2653:9;3037:36;3109:25;3120:4;3037:36;2937:27;2987;3109:10;:25::i;:::-;3102:32;;;;;;;;;2610:1086;3156:9;:16;3176:2;3156:22;3152:544;;;3479:4;3464:20;;3458:27;3530:4;3515:20;;3509:27;3572:23;3583:4;3458:27;3509;3572:10;:23::i;:::-;3565:30;;;;;;;;3152:544;-1:-1:-1;3644:1:1;;-1:-1:-1;3648:35:1;3152:544;2299:1404;;;;;:::o;570:643::-;648:20;639:5;:29;;;;;;;;:::i;:::-;;635:571;;;570:643;:::o;635:571::-;746:29;737:5;:38;;;;;;;;:::i;:::-;;733:473;;;792:34;;-1:-1:-1;;;792:34:1;;10235:2:10;792:34:1;;;10217:21:10;10274:2;10254:18;;;10247:30;10313:26;10293:18;;;10286:54;10357:18;;792:34:1;10033:348:10;733:473:1;857:35;848:5;:44;;;;;;;;:::i;:::-;;844:362;;;909:41;;-1:-1:-1;;;909:41:1;;12008:2:10;909:41:1;;;11990:21:10;12047:2;12027:18;;;12020:30;12086:33;12066:18;;;12059:61;12137:18;;909:41:1;11806:355:10;844:362:1;981:30;972:5;:39;;;;;;;;:::i;:::-;;968:238;;;1028:44;;-1:-1:-1;;;1028:44:1;;12775:2:10;1028:44:1;;;12757:21:10;12814:2;12794:18;;;12787:30;12853:34;12833:18;;;12826:62;12924:4;12904:18;;;12897:32;12946:19;;1028:44:1;12573:398:10;968:238:1;1103:30;1094:5;:39;;;;;;;;:::i;:::-;;1090:116;;;1150:44;;-1:-1:-1;;;1150:44:1;;14663:2:10;1150:44:1;;;14645:21:10;14702:2;14682:18;;;14675:30;14741:34;14721:18;;;14714:62;14812:4;14792:18;;;14785:32;14834:19;;1150:44:1;14461:398:10;14980:2236:2;15103:20;15126:13;-1:-1:-1;;;;;15154:16:2;;15150:48;;15179:19;;;;;;;;;;;;;;15150:48;15213:13;15209:44;;15235:18;;;;;;;;;;;;;;15209:44;-1:-1:-1;;;;;15802:22:2;;;;;;:18;:22;;;;1186:2;15802:22;;;:70;;15840:31;15828:44;;15802:70;;;16115:31;;;:17;:31;;;;;16208:15;1703:3;16208:41;16166:84;;-1:-1:-1;16286:13:2;;1966:3;16271:56;16166:162;16115:213;;:31;;16409:23;;;;16453:14;:19;16449:635;;16493:313;16524:38;;16549:12;;-1:-1:-1;;;;;16524:38:2;;;16541:1;;16524:38;;16541:1;;16524:38;16590:69;16629:1;16633:2;16637:14;;;;;;16653:5;16590:30;:69::i;:::-;16585:174;;16695:40;;;;;;;;;;;;;;16585:174;16801:3;16786:12;:18;16493:313;;16887:12;16870:13;;:29;16866:43;;16901:8;;;16866:43;16449:635;;;16950:119;16981:40;;17006:14;;;;;-1:-1:-1;;;;;16981:40:2;;;16998:1;;16981:40;;16998:1;;16981:40;17064:3;17049:12;:18;16950:119;;16449:635;-1:-1:-1;17098:13:2;:28;;;17148:60;;17181:2;17185:12;17199:8;17148:60;:::i;5957:1632:1:-;6088:7;;7022:66;7009:79;;7005:163;;;-1:-1:-1;7121:1:1;;-1:-1:-1;7125:30:1;7105:51;;7005:163;7182:1;:7;;7187:2;7182:7;;:18;;;;;7193:1;:7;;7198:2;7193:7;;7182:18;7178:102;;;-1:-1:-1;7233:1:1;;-1:-1:-1;7237:30:1;7217:51;;7178:102;7394:24;;;7377:14;7394:24;;;;;;;;;9633:25:10;;;9706:4;9694:17;;9674:18;;;9667:45;;;;9728:18;;;9721:34;;;9771:18;;;9764:34;;;7394:24:1;;9605:19:10;;7394:24:1;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;7394:24:1;;;;;;-1:-1:-1;;;;;;;7433:20:1;;7429:103;;7486:1;7490:29;7470:50;;;;;;;7429:103;7552:6;-1:-1:-1;7560:20:1;;-1:-1:-1;5957:1632:1;;;;;;;;:::o;4999:344::-;5113:7;;5172:66;5159:80;;5113:7;5266:25;5282:3;5267:18;;;5289:2;5266:25;:::i;:::-;5250:42;;5310:25;5321:4;5327:1;5330;5333;5310:10;:25::i;:::-;5303:32;;;;;;4999:344;;;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:690:10;78:5;108:18;149:2;141:6;138:14;135:40;;;155:18;;:::i;:::-;289:2;283:9;355:2;343:15;;194:66;339:24;;;365:2;335:33;331:42;319:55;;;389:18;;;409:22;;;386:46;383:72;;;435:18;;:::i;:::-;475:10;471:2;464:22;504:6;495:15;;534:6;526;519:22;574:3;565:6;560:3;556:16;553:25;550:45;;;591:1;588;581:12;550:45;641:6;636:3;629:4;621:6;617:17;604:44;696:1;689:4;680:6;672;668:19;664:30;657:41;;;;14:690;;;;;:::o;709:196::-;777:20;;-1:-1:-1;;;;;826:54:10;;816:65;;806:93;;895:1;892;885:12;806:93;709:196;;;:::o;910:160::-;975:20;;1031:13;;1024:21;1014:32;;1004:60;;1060:1;1057;1050:12;1075:347;1126:8;1136:6;1190:3;1183:4;1175:6;1171:17;1167:27;1157:55;;1208:1;1205;1198:12;1157:55;-1:-1:-1;1231:20:10;;1274:18;1263:30;;1260:50;;;1306:1;1303;1296:12;1260:50;1343:4;1335:6;1331:17;1319:29;;1395:3;1388:4;1379:6;1371;1367:19;1363:30;1360:39;1357:59;;;1412:1;1409;1402:12;1427:186;1486:6;1539:2;1527:9;1518:7;1514:23;1510:32;1507:52;;;1555:1;1552;1545:12;1507:52;1578:29;1597:9;1578:29;:::i;1618:260::-;1686:6;1694;1747:2;1735:9;1726:7;1722:23;1718:32;1715:52;;;1763:1;1760;1753:12;1715:52;1786:29;1805:9;1786:29;:::i;:::-;1776:39;;1834:38;1868:2;1857:9;1853:18;1834:38;:::i;:::-;1824:48;;1618:260;;;;;:::o;1883:328::-;1960:6;1968;1976;2029:2;2017:9;2008:7;2004:23;2000:32;1997:52;;;2045:1;2042;2035:12;1997:52;2068:29;2087:9;2068:29;:::i;:::-;2058:39;;2116:38;2150:2;2139:9;2135:18;2116:38;:::i;:::-;2106:48;;2201:2;2190:9;2186:18;2173:32;2163:42;;1883:328;;;;;:::o;2216:666::-;2311:6;2319;2327;2335;2388:3;2376:9;2367:7;2363:23;2359:33;2356:53;;;2405:1;2402;2395:12;2356:53;2428:29;2447:9;2428:29;:::i;:::-;2418:39;;2476:38;2510:2;2499:9;2495:18;2476:38;:::i;:::-;2466:48;;2561:2;2550:9;2546:18;2533:32;2523:42;;2616:2;2605:9;2601:18;2588:32;2643:18;2635:6;2632:30;2629:50;;;2675:1;2672;2665:12;2629:50;2698:22;;2751:4;2743:13;;2739:27;-1:-1:-1;2729:55:10;;2780:1;2777;2770:12;2729:55;2803:73;2868:7;2863:2;2850:16;2845:2;2841;2837:11;2803:73;:::i;:::-;2793:83;;;2216:666;;;;;;;:::o;2887:254::-;2952:6;2960;3013:2;3001:9;2992:7;2988:23;2984:32;2981:52;;;3029:1;3026;3019:12;2981:52;3052:29;3071:9;3052:29;:::i;:::-;3042:39;;3100:35;3131:2;3120:9;3116:18;3100:35;:::i;3146:254::-;3214:6;3222;3275:2;3263:9;3254:7;3250:23;3246:32;3243:52;;;3291:1;3288;3281:12;3243:52;3314:29;3333:9;3314:29;:::i;:::-;3304:39;3390:2;3375:18;;;;3362:32;;-1:-1:-1;;;3146:254:10:o;3405:245::-;3463:6;3516:2;3504:9;3495:7;3491:23;3487:32;3484:52;;;3532:1;3529;3522:12;3484:52;3571:9;3558:23;3590:30;3614:5;3590:30;:::i;3655:249::-;3724:6;3777:2;3765:9;3756:7;3752:23;3748:32;3745:52;;;3793:1;3790;3783:12;3745:52;3825:9;3819:16;3844:30;3868:5;3844:30;:::i;3909:409::-;3979:6;3987;4040:2;4028:9;4019:7;4015:23;4011:32;4008:52;;;4056:1;4053;4046:12;4008:52;4096:9;4083:23;4129:18;4121:6;4118:30;4115:50;;;4161:1;4158;4151:12;4115:50;4200:58;4250:7;4241:6;4230:9;4226:22;4200:58;:::i;:::-;4277:8;;4174:84;;-1:-1:-1;3909:409:10;-1:-1:-1;;;;3909:409:10:o;4323:450::-;4392:6;4445:2;4433:9;4424:7;4420:23;4416:32;4413:52;;;4461:1;4458;4451:12;4413:52;4501:9;4488:23;4534:18;4526:6;4523:30;4520:50;;;4566:1;4563;4556:12;4520:50;4589:22;;4642:4;4634:13;;4630:27;-1:-1:-1;4620:55:10;;4671:1;4668;4661:12;4620:55;4694:73;4759:7;4754:2;4741:16;4736:2;4732;4728:11;4694:73;:::i;4778:180::-;4837:6;4890:2;4878:9;4869:7;4865:23;4861:32;4858:52;;;4906:1;4903;4896:12;4858:52;-1:-1:-1;4929:23:10;;4778:180;-1:-1:-1;4778:180:10:o;4963:477::-;5042:6;5050;5058;5111:2;5099:9;5090:7;5086:23;5082:32;5079:52;;;5127:1;5124;5117:12;5079:52;5163:9;5150:23;5140:33;;5224:2;5213:9;5209:18;5196:32;5251:18;5243:6;5240:30;5237:50;;;5283:1;5280;5273:12;5237:50;5322:58;5372:7;5363:6;5352:9;5348:22;5322:58;:::i;:::-;4963:477;;5399:8;;-1:-1:-1;5296:84:10;;-1:-1:-1;;;;4963:477:10:o;5445:454::-;5537:6;5545;5553;5561;5569;5622:3;5610:9;5601:7;5597:23;5593:33;5590:53;;;5639:1;5636;5629:12;5590:53;5675:9;5662:23;5652:33;;5732:2;5721:9;5717:18;5704:32;5694:42;;5783:2;5772:9;5768:18;5755:32;5745:42;;5834:2;5823:9;5819:18;5806:32;5796:42;;5857:36;5888:3;5877:9;5873:19;5857:36;:::i;:::-;5847:46;;5445:454;;;;;;;;:::o;5904:316::-;5945:3;5983:5;5977:12;6010:6;6005:3;5998:19;6026:63;6082:6;6075:4;6070:3;6066:14;6059:4;6052:5;6048:16;6026:63;:::i;:::-;6134:2;6122:15;6139:66;6118:88;6109:98;;;;6209:4;6105:109;;5904:316;-1:-1:-1;;5904:316:10:o;6225:1642::-;6449:3;6487:6;6481:13;6513:4;6526:51;6570:6;6565:3;6560:2;6552:6;6548:15;6526:51;:::i;:::-;6640:13;;6599:16;;;;6662:55;6640:13;6599:16;6684:15;;;6662:55;:::i;:::-;6806:13;;6739:20;;;6779:1;;6866;6888:18;;;;6941;;;;6968:93;;7046:4;7036:8;7032:19;7020:31;;6968:93;7109:2;7099:8;7096:16;7076:18;7073:40;7070:224;;;7148:77;7143:3;7136:90;7249:4;7246:1;7239:15;7279:4;7274:3;7267:17;7070:224;7310:18;7337:168;;;;7519:1;7514:328;;;;7303:539;;7337:168;7387:66;7376:9;7372:82;7365:5;7358:97;7486:8;7479:5;7475:20;7468:27;;7337:168;;7514:328;16645:1;16638:14;;;16682:4;16669:18;;7609:1;7623:169;7637:8;7634:1;7631:15;7623:169;;;7719:14;;7704:13;;;7697:37;7762:16;;;;7654:10;;7623:169;;;7627:3;;7823:8;7816:5;7812:20;7805:27;;7303:539;-1:-1:-1;7858:3:10;;6225:1642;-1:-1:-1;;;;;;;;;;;6225:1642:10:o;8698:511::-;8892:4;-1:-1:-1;;;;;9002:2:10;8994:6;8990:15;8979:9;8972:34;9054:2;9046:6;9042:15;9037:2;9026:9;9022:18;9015:43;;9094:6;9089:2;9078:9;9074:18;9067:34;9137:3;9132:2;9121:9;9117:18;9110:31;9158:45;9198:3;9187:9;9183:19;9175:6;9158:45;:::i;:::-;9150:53;8698:511;-1:-1:-1;;;;;;8698:511:10:o;9809:219::-;9958:2;9947:9;9940:21;9921:4;9978:44;10018:2;10007:9;10003:18;9995:6;9978:44;:::i;16698:128::-;16738:3;16769:1;16765:6;16762:1;16759:13;16756:39;;;16775:18;;:::i;:::-;-1:-1:-1;16811:9:10;;16698:128::o;16831:120::-;16871:1;16897;16887:35;;16902:18;;:::i;:::-;-1:-1:-1;16936:9:10;;16831:120::o;16956:228::-;16996:7;17122:1;17054:66;17050:74;17047:1;17044:81;17039:1;17032:9;17025:17;17021:105;17018:131;;;17129:18;;:::i;:::-;-1:-1:-1;17169:9:10;;16956:228::o;17189:125::-;17229:4;17257:1;17254;17251:8;17248:34;;;17262:18;;:::i;:::-;-1:-1:-1;17299:9:10;;17189:125::o;17319:258::-;17391:1;17401:113;17415:6;17412:1;17409:13;17401:113;;;17491:11;;;17485:18;17472:11;;;17465:39;17437:2;17430:10;17401:113;;;17532:6;17529:1;17526:13;17523:48;;;-1:-1:-1;;17567:1:10;17549:16;;17542:27;17319:258::o;17582:437::-;17661:1;17657:12;;;;17704;;;17725:61;;17779:4;17771:6;17767:17;17757:27;;17725:61;17832:2;17824:6;17821:14;17801:18;17798:38;17795:218;;;17869:77;17866:1;17859:88;17970:4;17967:1;17960:15;17998:4;17995:1;17988:15;17795:218;;17582:437;;;:::o;18024:195::-;18063:3;18094:66;18087:5;18084:77;18081:103;;;18164:18;;:::i;:::-;-1:-1:-1;18211:1:10;18200:13;;18024:195::o;18224:112::-;18256:1;18282;18272:35;;18287:18;;:::i;:::-;-1:-1:-1;18321:9:10;;18224:112::o;18341:184::-;18393:77;18390:1;18383:88;18490:4;18487:1;18480:15;18514:4;18511:1;18504:15;18530:184;18582:77;18579:1;18572:88;18679:4;18676:1;18669:15;18703:4;18700:1;18693:15;18719:184;18771:77;18768:1;18761:88;18868:4;18865:1;18858:15;18892:4;18889:1;18882:15;18908:184;18960:77;18957:1;18950:88;19057:4;19054:1;19047:15;19081:4;19078:1;19071:15;19097:184;19149:77;19146:1;19139:88;19246:4;19243:1;19236:15;19270:4;19267:1;19260:15;19286:177;19371:66;19364:5;19360:78;19353:5;19350:89;19340:117;;19453:1;19450;19443:12

ipfs://152606fe1fac5ad75970a82f05dbb4187e7ecb63c13df077c1fc5a0088d2a2da