Token

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

//SPDX-License-Identifier: MIT
/*
-- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- -- -- - -- - -- - -- - -- - -- - -- - --
-  ______     __   __     ______     __  __     _____     ______     __    __     __     ______     __   __     -
- /\  __ \   /\ "-.\ \   /\  ___\   /\ \/ /    /\  __-.  /\  __ \   /\ "-./  \   /\ \   /\  __ \   /\ "-.\ \    -
- \ \  __ \  \ \ \-.  \  \ \  __\   \ \  _"-.  \ \ \/\ \ \ \  __ \  \ \ \-./\ \  \ \ \  \ \  __ \  \ \ \-.  \   -
-  \ \_\ \_\  \ \_\\"\_\  \ \_____\  \ \_\ \_\  \ \____-  \ \_\ \_\  \ \_\ \ \_\  \ \_\  \ \_\ \_\  \ \_\\"\_\  -
-   \/_/\/_/   \/_/ \/_/   \/_____/   \/_/\/_/   \/____/   \/_/\/_/   \/_/  \/_/   \/_/   \/_/\/_/   \/_/ \/_/  -
-                                                                                                               -    
-- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- -- -- - -- - -- - -- - -- - -- - -- - --


*/
pragma solidity ^0.8.4;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";

interface IADToken {
    function mint(uint256, address) external;
}

contract ADBoosterPacks is Ownable, ReentrancyGuard {
    IADToken private adTrainers;
    IADToken private adElementals;
    address public signerAddress;
    uint256 public constant tokenPrice = 0.0777 ether;
    uint256 public constant MAX_SUPPLY = 7770;
    uint256 public constant MAX_RESERVED = 100;
    uint256 public totalSupply = 0;
    uint256 public publicMintPerTxLimit = 2;
    uint256 public reserved;

    bool public allowListMintActive;
    bool public publicMintActive;

    mapping(address => uint256) public presaleMinted;

    modifier callerIsUser() {
        require(msg.sender == tx.origin, "Failed EOA check");
        _;
    }

    // ============ OWNER-ONLY ADMIN FUNCTIONS ============

    function setTokenAddresses(
        address _adElementalAddress,
        address _adTrainerAddress
    ) external onlyOwner {
        adElementals = IADToken(_adElementalAddress);
        adTrainers = IADToken(_adTrainerAddress);
    }

    function setPublicMintPerTxLimit(uint256 _limit) external onlyOwner {
        publicMintPerTxLimit = _limit;
    }

    function setPublicMintActive(bool val) public onlyOwner {
        publicMintActive = val;
    }

    function setAllowListMintActive(bool val) public onlyOwner {
        allowListMintActive = val;
    }

    function setSignerAddress(address _signerAddress) external onlyOwner {
        signerAddress = _signerAddress;
    }

    function withdrawAll() public onlyOwner nonReentrant {
        uint256 balance = address(this).balance;
        require(balance > 0);
        _widthdraw(owner(), address(this).balance);
    }

    function _widthdraw(address _address, uint256 _amount) private {
        (bool success, ) = _address.call{value: _amount}("");
        require(success, "Transfer failed");
    }

    // ============ PUBLIC FUNCTIONS FOR MINTING ============

    function mintPublic(uint256 _amount)
        external
        payable
        callerIsUser
        nonReentrant
    {
        require(publicMintActive, "Public mint has not started");
        require(
            _amount <= publicMintPerTxLimit,
            "Exceeded public mint per tx limit"
        );

        unchecked {
            uint256 supply = totalSupply;
            require(supply + _amount <= MAX_SUPPLY, "Exceeded max supply");
            totalSupply = supply + _amount;

            require(msg.value == _amount * tokenPrice, "Invalid amount of ETH");
        }

        _mint(_amount, msg.sender);
    }

    function mintAllowList(
        uint256 _amount,
        bytes memory _signature,
        uint256 _eligibleAmount
    ) external payable callerIsUser nonReentrant {
        require(allowListMintActive, "Allowlist mint has not started");
        require(
            verifySignature(
                keccak256(abi.encodePacked(msg.sender, _eligibleAmount)),
                _signature
            ),
            "Invalid signature"
        );
        require(
            _amount <= _eligibleAmount,
            "Mint amount exceeds eligible amount"
        );

        unchecked {
            uint256 minted = presaleMinted[msg.sender];
            require(
                minted + _amount <= _eligibleAmount,
                "Exceeded alowlist mint limit"
            );
            presaleMinted[msg.sender] = minted + _amount;

            uint256 supply = totalSupply;
            require(supply + _amount <= MAX_SUPPLY, "Exceeded max supply");
            totalSupply = supply + _amount;

            require(msg.value == _amount * tokenPrice, "Invalid amount of ETH");
        }

        _mint(_amount, msg.sender);
    }

    function reserve(uint256 _amount, address _to)
        external
        nonReentrant
        onlyOwner
    {
        unchecked {
            require(
                reserved + _amount <= MAX_RESERVED,
                "Exceeds maximum number of reserved tokens"
            );
            require(totalSupply + _amount <= MAX_SUPPLY, "Insufficient supply");
            totalSupply += _amount;
            reserved += _amount;
        }

        _mint(_amount, _to);
    }

    // ============ INTERNAL UTIL FUNCTIONS ============

    function _mint(uint256 _amount, address _to) private {
        adTrainers.mint(_amount, _to);
        adElementals.mint(_amount, _to);
    }

    function verifySignature(bytes32 _hash, bytes memory _signature)
        internal
        view
        returns (bool)
    {
        address recoveredAddress = ECDSA.recover(
            ECDSA.toEthSignedMessageHash(_hash),
            _signature
        );
        return (recoveredAddress != address(0) &&
            recoveredAddress == signerAddress);
    }
}

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

pragma solidity ^0.8.0;

import "../utils/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 v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (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.
            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.
            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;
        uint8 v;
        assembly {
            s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
            v := add(shr(255, vs), 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
// 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 v4.4.1 (utils/Strings.sol)

pragma solidity ^0.8.0;

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

    /**
     * @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);
    }
}

// SPDX-License-Identifier: MIT
// Creator: Chiru Labs

pragma solidity ^0.8.0;

import '@openzeppelin/contracts/token/ERC721/IERC721.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol';
import '@openzeppelin/contracts/utils/Address.sol';
import '@openzeppelin/contracts/utils/Context.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/introspection/ERC165.sol';

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
 *
 * Does not support burning tokens to address(0).
 *
 * Assumes that an owner cannot have more than the 2**128 - 1 (max value of uint128) of supply
 */
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
    using Address for address;
    using Strings for uint256;

    struct TokenOwnership {
        address addr;
        uint64 startTimestamp;
    }

    struct AddressData {
        uint128 balance;
        uint128 numberMinted;
    }

    uint256 internal currentIndex;

    // 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 ownershipOf implementation for details.
    mapping(uint256 => TokenOwnership) internal _ownerships;

    // Mapping owner address to address data
    mapping(address => AddressData) private _addressData;

    // 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_;
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        return currentIndex;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view override returns (uint256) {
        require(index < totalSupply(), 'ERC721A: global index out of bounds');
        return index;
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     * This read function is O(totalSupply). If calling from a separate contract, be sure to test gas first.
     * It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
        require(index < balanceOf(owner), 'ERC721A: owner index out of bounds');
        uint256 numMintedSoFar = totalSupply();
        uint256 tokenIdsIdx;
        address currOwnershipAddr;

        // Counter overflow is impossible as the loop breaks when uint256 i is equal to another uint256 numMintedSoFar.
        unchecked {
            for (uint256 i; i < numMintedSoFar; i++) {
                TokenOwnership memory ownership = _ownerships[i];
                if (ownership.addr != address(0)) {
                    currOwnershipAddr = ownership.addr;
                }
                if (currOwnershipAddr == owner) {
                    if (tokenIdsIdx == index) {
                        return i;
                    }
                    tokenIdsIdx++;
                }
            }
        }

        revert('ERC721A: unable to get token of owner by index');
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            interfaceId == type(IERC721Enumerable).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view override returns (uint256) {
        require(owner != address(0), 'ERC721A: balance query for the zero address');
        return uint256(_addressData[owner].balance);
    }

    function _numberMinted(address owner) internal view returns (uint256) {
        require(owner != address(0), 'ERC721A: number minted query for the zero address');
        return uint256(_addressData[owner].numberMinted);
    }

    /**
     * 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) {
        require(_exists(tokenId), 'ERC721A: owner query for nonexistent token');

        unchecked {
            for (uint256 curr = tokenId; curr >= 0; curr--) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (ownership.addr != address(0)) {
                    return ownership;
                }
            }
        }

        revert('ERC721A: unable to determine the owner of token');
    }

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

    /**
     * @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) {
        require(_exists(tokenId), 'ERC721Metadata: URI query for nonexistent token');

        string memory baseURI = _baseURI();
        return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : '';
    }

    /**
     * @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 See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public override {
        address owner = ERC721A.ownerOf(tokenId);
        require(to != owner, 'ERC721A: approval to current owner');

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            'ERC721A: approve caller is not owner nor approved for all'
        );

        _approve(to, tokenId, owner);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        require(_exists(tokenId), 'ERC721A: approved query for nonexistent token');

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public override {
        require(operator != _msgSender(), 'ERC721A: approve to caller');

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), 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 override {
        _transfer(from, to, tokenId);
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public override {
        _transfer(from, to, tokenId);
        require(
            _checkOnERC721Received(from, to, tokenId, _data),
            'ERC721A: transfer to non ERC721Receiver implementer'
        );
    }

    /**
     * @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 tokenId < currentIndex;
    }

    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 {
        _mint(to, quantity, _data, true);
    }

    /**
     * @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,
        bytes memory _data,
        bool safe
    ) internal {
        uint256 startTokenId = currentIndex;
        require(to != address(0), 'ERC721A: mint to the zero address');
        require(quantity != 0, 'ERC721A: quantity must be greater than 0');

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 3.4e38 (2**128) - 1
        // updatedIndex overflows if currentIndex + quantity > 1.56e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint128(quantity);
            _addressData[to].numberMinted += uint128(quantity);

            _ownerships[startTokenId].addr = to;
            _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

            uint256 updatedIndex = startTokenId;

            for (uint256 i; i < quantity; i++) {
                emit Transfer(address(0), to, updatedIndex);
                if (safe) {
                    require(
                        _checkOnERC721Received(address(0), to, updatedIndex, _data),
                        'ERC721A: transfer to non ERC721Receiver implementer'
                    );
                }

                updatedIndex++;
            }

            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 {
        TokenOwnership memory prevOwnership = ownershipOf(tokenId);

        bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
            getApproved(tokenId) == _msgSender() ||
            isApprovedForAll(prevOwnership.addr, _msgSender()));

        require(isApprovedOrOwner, 'ERC721A: transfer caller is not owner nor approved');

        require(prevOwnership.addr == from, 'ERC721A: transfer from incorrect owner');
        require(to != address(0), 'ERC721A: transfer to the zero address');

        _beforeTokenTransfers(from, to, tokenId, 1);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId, prevOwnership.addr);

        // 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 {
            _addressData[from].balance -= 1;
            _addressData[to].balance += 1;

            _ownerships[tokenId].addr = to;
            _ownerships[tokenId].startTimestamp = uint64(block.timestamp);

            // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            if (_ownerships[nextTokenId].addr == address(0)) {
                if (_exists(nextTokenId)) {
                    _ownerships[nextTokenId].addr = prevOwnership.addr;
                    _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

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

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(
        address to,
        uint256 tokenId,
        address owner
    ) private {
        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a 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 _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver(to).onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert('ERC721A: transfer to non ERC721Receiver implementer');
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     *
     * 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`.
     */
    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.
     *
     * 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` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @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`, 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 Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @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 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);

    /**
     * @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;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @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
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;

import "../IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

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

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

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

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface 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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
        @dev Handles the receipt of a single ERC1155 token type. This function is
        called at the end of a `safeTransferFrom` after the balance has been updated.
        To accept the transfer, this must return
        `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
        (i.e. 0xf23a6e61, or its own function selector).
        @param operator The address which initiated the transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param id The ID of the token being transferred
        @param value The amount of tokens being transferred
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
    */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
        @dev Handles the receipt of a multiple ERC1155 token types. This function
        is called at the end of a `safeBatchTransferFrom` after the balances have
        been updated. To accept the transfer(s), this must return
        `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
        (i.e. 0xbc197c81, or its own function selector).
        @param operator The address which initiated the batch transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param ids An array containing ids of each token being transferred (order and length must match values array)
        @param values An array containing amounts of each token being transferred (order and length must match ids array)
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
    */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/ERC1155.sol)

pragma solidity ^0.8.0;

import "./IERC1155.sol";
import "./IERC1155Receiver.sol";
import "./extensions/IERC1155MetadataURI.sol";
import "../../utils/Address.sol";
import "../../utils/Context.sol";
import "../../utils/introspection/ERC165.sol";

/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 *
 * _Available since v3.1._
 */
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
    using Address for address;

    // Mapping from token ID to account balances
    mapping(uint256 => mapping(address => uint256)) private _balances;

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

    // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
    string private _uri;

    /**
     * @dev See {_setURI}.
     */
    constructor(string memory uri_) {
        _setURI(uri_);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC1155).interfaceId ||
            interfaceId == type(IERC1155MetadataURI).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC1155MetadataURI-uri}.
     *
     * This implementation returns the same URI for *all* token types. It relies
     * on the token type ID substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * Clients calling this function must replace the `\{id\}` substring with the
     * actual token type ID.
     */
    function uri(uint256) public view virtual override returns (string memory) {
        return _uri;
    }

    /**
     * @dev See {IERC1155-balanceOf}.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
        require(account != address(0), "ERC1155: balance query for the zero address");
        return _balances[id][account];
    }

    /**
     * @dev See {IERC1155-balanceOfBatch}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
        public
        view
        virtual
        override
        returns (uint256[] memory)
    {
        require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");

        uint256[] memory batchBalances = new uint256[](accounts.length);

        for (uint256 i = 0; i < accounts.length; ++i) {
            batchBalances[i] = balanceOf(accounts[i], ids[i]);
        }

        return batchBalances;
    }

    /**
     * @dev See {IERC1155-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

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

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not owner nor approved"
        );
        _safeTransferFrom(from, to, id, amount, data);
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: transfer caller is not owner nor approved"
        );
        _safeBatchTransferFrom(from, to, ids, amounts, data);
    }

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: transfer to the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), data);

        uint256 fromBalance = _balances[id][from];
        require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
        unchecked {
            _balances[id][from] = fromBalance - amount;
        }
        _balances[id][to] += amount;

        emit TransferSingle(operator, from, to, id, amount);

        _doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
        require(to != address(0), "ERC1155: transfer to the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, ids, amounts, data);

        for (uint256 i = 0; i < ids.length; ++i) {
            uint256 id = ids[i];
            uint256 amount = amounts[i];

            uint256 fromBalance = _balances[id][from];
            require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
            unchecked {
                _balances[id][from] = fromBalance - amount;
            }
            _balances[id][to] += amount;
        }

        emit TransferBatch(operator, from, to, ids, amounts);

        _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
    }

    /**
     * @dev Sets a new URI for all token types, by relying on the token type ID
     * substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * By this mechanism, any occurrence of the `\{id\}` substring in either the
     * URI or any of the amounts in the JSON file at said URI will be replaced by
     * clients with the token type ID.
     *
     * For example, the `https://token-cdn-domain/\{id\}.json` URI would be
     * interpreted by clients as
     * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
     * for token type ID 0x4cce0.
     *
     * See {uri}.
     *
     * Because these URIs cannot be meaningfully represented by the {URI} event,
     * this function emits no events.
     */
    function _setURI(string memory newuri) internal virtual {
        _uri = newuri;
    }

    /**
     * @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, address(0), to, _asSingletonArray(id), _asSingletonArray(amount), data);

        _balances[id][to] += amount;
        emit TransferSingle(operator, address(0), to, id, amount);

        _doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);

        for (uint256 i = 0; i < ids.length; i++) {
            _balances[ids[i]][to] += amounts[i];
        }

        emit TransferBatch(operator, address(0), to, ids, amounts);

        _doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
    }

    /**
     * @dev Destroys `amount` tokens of token type `id` from `from`
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have at least `amount` tokens of token type `id`.
     */
    function _burn(
        address from,
        uint256 id,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC1155: burn from the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, address(0), _asSingletonArray(id), _asSingletonArray(amount), "");

        uint256 fromBalance = _balances[id][from];
        require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
        unchecked {
            _balances[id][from] = fromBalance - amount;
        }

        emit TransferSingle(operator, from, address(0), id, amount);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     */
    function _burnBatch(
        address from,
        uint256[] memory ids,
        uint256[] memory amounts
    ) internal virtual {
        require(from != address(0), "ERC1155: burn from the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, address(0), ids, amounts, "");

        for (uint256 i = 0; i < ids.length; i++) {
            uint256 id = ids[i];
            uint256 amount = amounts[i];

            uint256 fromBalance = _balances[id][from];
            require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
            unchecked {
                _balances[id][from] = fromBalance - amount;
            }
        }

        emit TransferBatch(operator, from, address(0), ids, amounts);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC1155: setting approval status for self");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning, as well as batched variants.
     *
     * The same hook is called on both single and batched variants. For single
     * transfers, the length of the `id` and `amount` arrays will be 1.
     *
     * Calling conditions (for each `id` and `amount` pair):
     *
     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * of token type `id` will be  transferred to `to`.
     * - When `from` is zero, `amount` tokens of token type `id` will be minted
     * for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
     * will be burned.
     * - `from` and `to` are never both zero.
     * - `ids` and `amounts` have the same, non-zero length.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}

    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
                if (response != IERC1155Receiver.onERC1155Received.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
                bytes4 response
            ) {
                if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

    function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
        uint256[] memory array = new uint256[](1);
        array[0] = element;

        return array;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external
        view
        returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)

pragma solidity ^0.8.0;

import "../IERC1155.sol";

/**
 * @dev Interface of the optional ERC1155MetadataExtension interface, as defined
 * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155MetadataURI is IERC1155 {
    /**
     * @dev Returns the URI for token type `id`.
     *
     * If the `\{id\}` substring is present in the URI, it must be replaced by
     * clients with the actual token type ID.
     */
    function uri(uint256 id) external view returns (string memory);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/ERC1155Supply.sol)

pragma solidity ^0.8.0;

import "../ERC1155.sol";

/**
 * @dev Extension of ERC1155 that adds tracking of total supply per id.
 *
 * Useful for scenarios where Fungible and Non-fungible tokens have to be
 * clearly identified. Note: While a totalSupply of 1 might mean the
 * corresponding is an NFT, there is no guarantees that no other token with the
 * same id are not going to be minted.
 */
abstract contract ERC1155Supply is ERC1155 {
    mapping(uint256 => uint256) private _totalSupply;

    /**
     * @dev Total amount of tokens in with a given id.
     */
    function totalSupply(uint256 id) public view virtual returns (uint256) {
        return _totalSupply[id];
    }

    /**
     * @dev Indicates whether any token exist with a given id, or not.
     */
    function exists(uint256 id) public view virtual returns (bool) {
        return ERC1155Supply.totalSupply(id) > 0;
    }

    /**
     * @dev See {ERC1155-_beforeTokenTransfer}.
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual override {
        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);

        if (from == address(0)) {
            for (uint256 i = 0; i < ids.length; ++i) {
                _totalSupply[ids[i]] += amounts[i];
            }
        }

        if (to == address(0)) {
            for (uint256 i = 0; i < ids.length; ++i) {
                _totalSupply[ids[i]] -= amounts[i];
            }
        }
    }
}

// SPDX-License-Identifier: MIT
/*
-- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- -- -- - -- - -- - -- - -- - -- - -- - --
-  ______     __   __     ______     __  __     _____     ______     __    __     __     ______     __   __     -
- /\  __ \   /\ "-.\ \   /\  ___\   /\ \/ /    /\  __-.  /\  __ \   /\ "-./  \   /\ \   /\  __ \   /\ "-.\ \    -
- \ \  __ \  \ \ \-.  \  \ \  __\   \ \  _"-.  \ \ \/\ \ \ \  __ \  \ \ \-./\ \  \ \ \  \ \  __ \  \ \ \-.  \   -
-  \ \_\ \_\  \ \_\\"\_\  \ \_____\  \ \_\ \_\  \ \____-  \ \_\ \_\  \ \_\ \ \_\  \ \_\  \ \_\ \_\  \ \_\\"\_\  -
-   \/_/\/_/   \/_/ \/_/   \/_____/   \/_/\/_/   \/____/   \/_/\/_/   \/_/  \/_/   \/_/   \/_/\/_/   \/_/ \/_/  -
-                                                                                                               -    
-- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- -- -- - -- - -- - -- - -- - -- - -- - --


*/

pragma solidity ^0.8.4;

import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

interface IADRandomizer {
    function rand(address) external view returns (uint256);
}

contract ADElementals is ERC1155Supply, ERC1155Burnable, Ownable {
    using Strings for uint256;

    // Token IDs
    uint256 public constant GRASS = 0;
    uint256 public constant WATER = 1;
    uint256 public constant FIRE = 2;
    uint256 public constant PSYCHIC = 3;
    uint256 public constant SPECIAL = 4;

    uint256 public constant ELEMENTALS_PER_BATCH = 3;

    string private name_;
    string private symbol_;

    address public adBoosterPackAddress;
    address private adRandomizerAddress;

    IADRandomizer adRandomizer;

    // ============ ACCESS CONTROL/SANITY MODIFIERS ============

    modifier callerIsADBoosterPack() {
        require(
            msg.sender == adBoosterPackAddress,
            "Caller is not ADBoosterPack contract"
        );
        _;
    }

    constructor(
        address _adBoosterPackAddress,
        address _adRandomizerAddress,
        string memory _name,
        string memory _symbol,
        string memory _uri
    ) ERC1155(_uri) {
        adBoosterPackAddress = _adBoosterPackAddress;
        adRandomizer = IADRandomizer(_adRandomizerAddress);
        name_ = _name;
        symbol_ = _symbol;
    }

    // ============ PUBLIC FUNCTIONS FOR MINTING ============

    /**
     * @dev Generic mint function to be called by the ADBoosterPacks contract for both
     * whitelist and public sales.
     * Can only be called by the ADBoosterPacks contract.
     * Probability of minting each Elemental card:
     * - special 3%
     * - psychic 12%
     * - fire 15%
     * - water 30%
     * - grass 40%
     */
    function mint(uint256 _batch, address _to) external callerIsADBoosterPack {
        unchecked {
            uint256 numElementals = _batch * ELEMENTALS_PER_BATCH;
            uint256[] memory randomValues = expandRandomness(
                rand(_to),
                numElementals
            );
            for (uint256 i = 0; i < numElementals; i++) {
                uint256 rarityScore = randomValues[i] % 100;

                if (rarityScore < 40) {
                    _mint(_to, GRASS, 1, "");
                } else if (rarityScore < 70) {
                    _mint(_to, WATER, 1, "");
                } else if (rarityScore < 85) {
                    _mint(_to, FIRE, 1, "");
                } else if (rarityScore < 97) {
                    _mint(_to, PSYCHIC, 1, "");
                } else {
                    _mint(_to, SPECIAL, 1, "");
                }
            }
        }
    }

    // ============ PUBLIC READ-ONLY FUNCTIONS ============

    function name() public view returns (string memory) {
        return name_;
    }

    function symbol() public view returns (string memory) {
        return symbol_;
    }

    function uri(uint256 _id) public view override returns (string memory) {
        require(exists(_id), "Nonexistent token");

        return string(abi.encodePacked(super.uri(_id), _id.toString()));
    }

    // ============ INTERNAL UTIL FUNCTIONS ============

    function expandRandomness(uint256 randomValue, uint256 n)
        internal
        pure
        returns (uint256[] memory expandedValues)
    {
        expandedValues = new uint256[](n);
        for (uint256 i = 0; i < n; i++) {
            expandedValues[i] = uint256(keccak256(abi.encode(randomValue, i)));
        }
        return expandedValues;
    }

    function rand(address _to) internal view returns (uint256 randomValue) {
        randomValue = adRandomizer.rand(_to);
    }

    // ============ OWNER-ONLY ADMIN FUNCTIONS ============

    function setADBoosterPackAddress(address _adBoosterPackAddress)
        external
        onlyOwner
    {
        adBoosterPackAddress = _adBoosterPackAddress;
    }

    function setADRandomizerAddress(address _adRandomizerAddress)
        external
        onlyOwner
    {
        adRandomizerAddress = _adRandomizerAddress;
    }

    function setBaseURI(string memory _baseURI) external onlyOwner {
        _setURI(_baseURI);
    }

    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual override(ERC1155, ERC1155Supply) {
        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/ERC1155Burnable.sol)

pragma solidity ^0.8.0;

import "../ERC1155.sol";

/**
 * @dev Extension of {ERC1155} that allows token holders to destroy both their
 * own tokens and those that they have been approved to use.
 *
 * _Available since v3.1._
 */
abstract contract ERC1155Burnable is ERC1155 {
    function burn(
        address account,
        uint256 id,
        uint256 value
    ) public virtual {
        require(
            account == _msgSender() || isApprovedForAll(account, _msgSender()),
            "ERC1155: caller is not owner nor approved"
        );

        _burn(account, id, value);
    }

    function burnBatch(
        address account,
        uint256[] memory ids,
        uint256[] memory values
    ) public virtual {
        require(
            account == _msgSender() || isApprovedForAll(account, _msgSender()),
            "ERC1155: caller is not owner nor approved"
        );

        _burnBatch(account, ids, values);
    }
}

//SPDX-License-Identifier: MIT
/*
-- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- -- -- - -- - -- - -- - -- - -- - -- - --
-  ______     __   __     ______     __  __     _____     ______     __    __     __     ______     __   __     -
- /\  __ \   /\ "-.\ \   /\  ___\   /\ \/ /    /\  __-.  /\  __ \   /\ "-./  \   /\ \   /\  __ \   /\ "-.\ \    -
- \ \  __ \  \ \ \-.  \  \ \  __\   \ \  _"-.  \ \ \/\ \ \ \  __ \  \ \ \-./\ \  \ \ \  \ \  __ \  \ \ \-.  \   -
-  \ \_\ \_\  \ \_\\"\_\  \ \_____\  \ \_\ \_\  \ \____-  \ \_\ \_\  \ \_\ \ \_\  \ \_\  \ \_\ \_\  \ \_\\"\_\  -
-   \/_/\/_/   \/_/ \/_/   \/_____/   \/_/\/_/   \/____/   \/_/\/_/   \/_/  \/_/   \/_/   \/_/\/_/   \/_/ \/_/  -
-                                                                                                               -    
-- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- - -- -- -- - -- - -- - -- - -- - -- - -- - --


*/

pragma solidity ^0.8.4;

import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract ADTrainers is ERC721A, Ownable {
    address public adBoosterPackAddress;
    uint256 public constant MAX_SUPPLY = 7770;
    bool public revealed;

    // URI settings
    string public baseTokenURI;
    string public placeholderURI;

    // These proxy address will be approved to interact
    // with ADTrainers for future staking and gaming features
    mapping(address => bool) public proxyToApprove;

    constructor(
        address _adBoosterPackAddress,
        string memory _name,
        string memory _symbol
    ) ERC721A(_name, _symbol) {
        adBoosterPackAddress = _adBoosterPackAddress;
    }

    // ============ ACCESS CONTROL/SANITY MODIFIERS ============

    modifier callerIsADBoosterPack() {
        require(
            msg.sender == adBoosterPackAddress,
            "Caller is not ADBoosterPack contract"
        );
        _;
    }

    // ============ PUBLIC FUNCTIONS FOR MINTING ============

    /**
     * @dev Generic mint function to be called by the ADBoosterPacks contract for both
     * whitelist and public sales.
     * Can only be called by the ADBoosterPacks contract.
     */
    function mint(uint256 _quantity, address _to)
        external
        callerIsADBoosterPack
    {
        require(
            totalSupply() + _quantity <= MAX_SUPPLY,
            "Max supply has been reached"
        );
        _safeMint(_to, _quantity);
    }

    // ============ PUBLIC READ-ONLY FUNCTIONS ============

    function tokenURI(uint256 _id)
        public
        view
        virtual
        override
        returns (string memory)
    {
        require(_exists(_id), "Nonexistent token");

        return revealed ? super.tokenURI(_id) : placeholderURI;
    }

    function numberMinted(address _owner) public view returns (uint256) {
        return _numberMinted(_owner);
    }

    function tokensOfOwner(address _owner)
        external
        view
        returns (uint256[] memory)
    {
        uint256 tokenCount = balanceOf(_owner);

        uint256[] memory tokensIds = new uint256[](tokenCount);
        for (uint256 i; i < tokenCount; i++) {
            tokensIds[i] = tokenOfOwnerByIndex(_owner, i);
        }
        return tokensIds;
    }

    function _baseURI() internal view virtual override returns (string memory) {
        return baseTokenURI;
    }

    function isApprovedForAll(address _owner, address _operator)
        public
        view
        override
        returns (bool)
    {
        if (proxyToApprove[_operator]) {
            return true;
        }

        return super.isApprovedForAll(_owner, _operator);
    }

    // ============ OWNER-ONLY ADMIN FUNCTIONS ============

    function setADBoosterPackAddress(address _adBoosterPackAddress)
        external
        onlyOwner
    {
        adBoosterPackAddress = _adBoosterPackAddress;
    }

    function setBaseURI(string calldata _URI) external onlyOwner {
        baseTokenURI = _URI;
    }

    function setPlaceholderURI(string memory _URI) external onlyOwner {
        placeholderURI = _URI;
    }

    function flipRevealed() external onlyOwner {
        revealed = !revealed;
    }

    function flipProxyState(address _proxyAddress) external onlyOwner {
        proxyToApprove[_proxyAddress] = !proxyToApprove[_proxyAddress];
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 500
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_adBoosterPackAddress","type":"address"},{"internalType":"address","name":"_adRandomizerAddress","type":"address"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"string","name":"_uri","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","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":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[],"name":"ELEMENTALS_PER_BATCH","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FIRE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GRASS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PSYCHIC","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SPECIAL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WATER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"adBoosterPackAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"burnBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_batch","type":"uint256"},{"internalType":"address","name":"_to","type":"address"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","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":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_adBoosterPackAddress","type":"address"}],"name":"setADBoosterPackAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_adRandomizerAddress","type":"address"}],"name":"setADRandomizerAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseURI","type":"string"}],"name":"setBaseURI","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":"uint256","name":"id","type":"uint256"}],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]

60806040523480156200001157600080fd5b5060405162002d0e38038062002d0e833981016040819052620000349162000294565b806200004081620000b3565b506200004c33620000cc565b600780546001600160a01b038088166001600160a01b03199283161790925560098054928716929091169190911790558251620000919060059060208601906200011e565b508151620000a79060069060208501906200011e565b5050505050506200039b565b8051620000c89060029060208401906200011e565b5050565b600480546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b8280546200012c9062000348565b90600052602060002090601f0160209004810192826200015057600085556200019b565b82601f106200016b57805160ff19168380011785556200019b565b828001600101855582156200019b579182015b828111156200019b5782518255916020019190600101906200017e565b50620001a9929150620001ad565b5090565b5b80821115620001a95760008155600101620001ae565b80516001600160a01b0381168114620001dc57600080fd5b919050565b600082601f830112620001f2578081fd5b81516001600160401b03808211156200020f576200020f62000385565b604051601f8301601f19908116603f011681019082821181831017156200023a576200023a62000385565b8160405283815260209250868385880101111562000256578485fd5b8491505b838210156200027957858201830151818301840152908201906200025a565b838211156200028a57848385830101525b9695505050505050565b600080600080600060a08688031215620002ac578081fd5b620002b786620001c4565b9450620002c760208701620001c4565b60408701519094506001600160401b0380821115620002e4578283fd5b620002f289838a01620001e1565b9450606088015191508082111562000308578283fd5b6200031689838a01620001e1565b935060808801519150808211156200032c578283fd5b506200033b88828901620001e1565b9150509295509295909350565b600181811c908216806200035d57607f821691505b602082108114156200037f57634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052604160045260246000fd5b61296380620003ab6000396000f3fe608060405234801561001057600080fd5b50600436106101c35760003560e01c8063715018a6116100f9578063bd85b03911610097578063e985e9c511610071578063e985e9c514610396578063f242432a146103d2578063f2fde38b146103e5578063f5298aca146103f857600080fd5b8063bd85b03914610350578063d11fd95614610370578063dd64dcb01461038357600080fd5b80638da5cb5b116100d35780638da5cb5b1461031157806394bf804d1461032257806395d89b4114610335578063a22cb4651461033d57600080fd5b8063715018a6146103015780638d304590146103095780638d3afedf1461025e57600080fd5b80634aa396f411610166578063551b1ff911610140578063551b1ff9146102a857806355f804b3146102d35780635691dfe0146102e65780636b20c454146102ee57600080fd5b80634aa396f41461025e5780634e1273f4146102665780634f558e791461028657600080fd5b806306fdde03116101a257806306fdde03146102195780630e89341c1461022e5780632eb2c2d61461024157806335b2f4741461025657600080fd5b8062fdd58e146101c857806301ffc9a7146101ee578063026e711014610211575b600080fd5b6101db6101d6366004612385565b61040b565b6040519081526020015b60405180910390f35b6102016101fc3660046124ab565b6104a2565b60405190151581526020016101e5565b6101db600481565b6102216104f4565b6040516101e591906126f2565b61022161023c366004612529565b610586565b61025461024f3660046121d1565b61061d565b005b6101db600281565b6101db600381565b6102796102743660046123e0565b6106bf565b6040516101e591906126b1565b610201610294366004612529565b600090815260036020526040902054151590565b6007546102bb906001600160a01b031681565b6040516001600160a01b0390911681526020016101e5565b6102546102e13660046124e3565b610821565b6101db600181565b6102546102fc3660046122da565b610887565b610254610911565b6101db600081565b6004546001600160a01b03166102bb565b610254610330366004612559565b610977565b610221610b0e565b61025461034b36600461234b565b610b1d565b6101db61035e366004612529565b60009081526003602052604090205490565b61025461037e366004612185565b610b2c565b610254610391366004612185565b610ba8565b6102016103a436600461219f565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205460ff1690565b6102546103e0366004612277565b610c24565b6102546103f3366004612185565b610cab565b6102546104063660046123ae565b610d73565b60006001600160a01b03831661047c5760405162461bcd60e51b815260206004820152602b60248201527f455243313135353a2062616c616e636520717565727920666f7220746865207a60448201526a65726f206164647265737360a81b60648201526084015b60405180910390fd5b506000908152602081815260408083206001600160a01b03949094168352929052205490565b60006001600160e01b03198216636cdb3d1360e11b14806104d357506001600160e01b031982166303a24d0760e21b145b806104ee57506301ffc9a760e01b6001600160e01b03198316145b92915050565b6060600580546105039061279c565b80601f016020809104026020016040519081016040528092919081815260200182805461052f9061279c565b801561057c5780601f106105515761010080835404028352916020019161057c565b820191906000526020600020905b81548152906001019060200180831161055f57829003601f168201915b5050505050905090565b6000818152600360205260409020546060906105e45760405162461bcd60e51b815260206004820152601160248201527f4e6f6e6578697374656e7420746f6b656e0000000000000000000000000000006044820152606401610473565b6105ed82610df8565b6105f683610e8c565b6040516020016106079291906125e1565b6040516020818303038152906040529050919050565b6001600160a01b038516331480610639575061063985336103a4565b6106ab5760405162461bcd60e51b815260206004820152603260248201527f455243313135353a207472616e736665722063616c6c6572206973206e6f742060448201527f6f776e6572206e6f7220617070726f76656400000000000000000000000000006064820152608401610473565b6106b88585858585610fc6565b5050505050565b606081518351146107245760405162461bcd60e51b815260206004820152602960248201527f455243313135353a206163636f756e747320616e6420696473206c656e677468604482015268040dad2e6dac2e8c6d60bb1b6064820152608401610473565b6000835167ffffffffffffffff81111561074e57634e487b7160e01b600052604160045260246000fd5b604051908082528060200260200182016040528015610777578160200160208202803683370190505b50905060005b8451811015610819576107de8582815181106107a957634e487b7160e01b600052603260045260246000fd5b60200260200101518583815181106107d157634e487b7160e01b600052603260045260246000fd5b602002602001015161040b565b8282815181106107fe57634e487b7160e01b600052603260045260246000fd5b602090810291909101015261081281612804565b905061077d565b509392505050565b6004546001600160a01b0316331461087b5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610473565b6108848161124e565b50565b6001600160a01b0383163314806108a357506108a383336103a4565b6109015760405162461bcd60e51b815260206004820152602960248201527f455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f7260448201526808185c1c1c9bdd995960ba1b6064820152608401610473565b61090c838383611261565b505050565b6004546001600160a01b0316331461096b5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610473565b61097560006114c4565b565b6007546001600160a01b031633146109dd5760405162461bcd60e51b8152602060048201526024808201527f43616c6c6572206973206e6f74204144426f6f737465725061636b20636f6e746044820152631c9858dd60e21b6064820152608401610473565b6003820260006109f56109ef84611516565b83611594565b905060005b828110156106b85760006064838381518110610a2657634e487b7160e01b600052603260045260246000fd5b602002602001015181610a4957634e487b7160e01b600052601260045260246000fd5b0690506028811015610a7757610a72856000600160405180602001604052806000815250611665565b610b05565b6046811015610a9c57610a728560018060405180602001604052806000815250611665565b6055811015610ac257610a72856002600160405180602001604052806000815250611665565b6061811015610ae857610a72856003600160405180602001604052806000815250611665565b610b05856004600160405180602001604052806000815250611665565b506001016109fa565b6060600680546105039061279c565b610b28338383611775565b5050565b6004546001600160a01b03163314610b865760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610473565b600880546001600160a01b0319166001600160a01b0392909216919091179055565b6004546001600160a01b03163314610c025760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610473565b600780546001600160a01b0319166001600160a01b0392909216919091179055565b6001600160a01b038516331480610c405750610c4085336103a4565b610c9e5760405162461bcd60e51b815260206004820152602960248201527f455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f7260448201526808185c1c1c9bdd995960ba1b6064820152608401610473565b6106b88585858585611856565b6004546001600160a01b03163314610d055760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610473565b6001600160a01b038116610d6a5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610473565b610884816114c4565b6001600160a01b038316331480610d8f5750610d8f83336103a4565b610ded5760405162461bcd60e51b815260206004820152602960248201527f455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f7260448201526808185c1c1c9bdd995960ba1b6064820152608401610473565b61090c8383836119f4565b606060028054610e079061279c565b80601f0160208091040260200160405190810160405280929190818152602001828054610e339061279c565b8015610e805780601f10610e5557610100808354040283529160200191610e80565b820191906000526020600020905b815481529060010190602001808311610e6357829003601f168201915b50505050509050919050565b606081610eb05750506040805180820190915260018152600360fc1b602082015290565b8160005b8115610eda5780610ec481612804565b9150610ed39050600a83612741565b9150610eb4565b60008167ffffffffffffffff811115610f0357634e487b7160e01b600052604160045260246000fd5b6040519080825280601f01601f191660200182016040528015610f2d576020820181803683370190505b5090505b8415610fbe57610f42600183612755565b9150610f4f600a8661281f565b610f5a906030612729565b60f81b818381518110610f7d57634e487b7160e01b600052603260045260246000fd5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a905350610fb7600a86612741565b9450610f31565b949350505050565b81518351146110285760405162461bcd60e51b815260206004820152602860248201527f455243313135353a2069647320616e6420616d6f756e7473206c656e677468206044820152670dad2e6dac2e8c6d60c31b6064820152608401610473565b6001600160a01b03841661108c5760405162461bcd60e51b815260206004820152602560248201527f455243313135353a207472616e7366657220746f20746865207a65726f206164604482015264647265737360d81b6064820152608401610473565b3361109b818787878787611b6d565b60005b84518110156111e05760008582815181106110c957634e487b7160e01b600052603260045260246000fd5b6020026020010151905060008583815181106110f557634e487b7160e01b600052603260045260246000fd5b602090810291909101810151600084815280835260408082206001600160a01b038e1683529093529190912054909150818110156111885760405162461bcd60e51b815260206004820152602a60248201527f455243313135353a20696e73756666696369656e742062616c616e636520666f60448201526939103a3930b739b332b960b11b6064820152608401610473565b6000838152602081815260408083206001600160a01b038e8116855292528083208585039055908b168252812080548492906111c5908490612729565b92505081905550505050806111d990612804565b905061109e565b50846001600160a01b0316866001600160a01b0316826001600160a01b03167f4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb87876040516112309291906126c4565b60405180910390a4611246818787878787611b7b565b505050505050565b8051610b28906002906020840190611fd8565b6001600160a01b0383166112c35760405162461bcd60e51b815260206004820152602360248201527f455243313135353a206275726e2066726f6d20746865207a65726f206164647260448201526265737360e81b6064820152608401610473565b80518251146113255760405162461bcd60e51b815260206004820152602860248201527f455243313135353a2069647320616e6420616d6f756e7473206c656e677468206044820152670dad2e6dac2e8c6d60c31b6064820152608401610473565b600033905061134881856000868660405180602001604052806000815250611b6d565b60005b835181101561146557600084828151811061137657634e487b7160e01b600052603260045260246000fd5b6020026020010151905060008483815181106113a257634e487b7160e01b600052603260045260246000fd5b602090810291909101810151600084815280835260408082206001600160a01b038c16835290935291909120549091508181101561142e5760405162461bcd60e51b8152602060048201526024808201527f455243313135353a206275726e20616d6f756e7420657863656564732062616c604482015263616e636560e01b6064820152608401610473565b6000928352602083815260408085206001600160a01b038b168652909152909220910390558061145d81612804565b91505061134b565b5060006001600160a01b0316846001600160a01b0316826001600160a01b03167f4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb86866040516114b69291906126c4565b60405180910390a450505050565b600480546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b6009546040516363e312f760e11b81526001600160a01b038381166004830152600092169063c7c625ee9060240160206040518083038186803b15801561155c57600080fd5b505afa158015611570573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906104ee9190612541565b60608167ffffffffffffffff8111156115bd57634e487b7160e01b600052604160045260246000fd5b6040519080825280602002602001820160405280156115e6578160200160208202803683370190505b50905060005b8281101561165e5760408051602081018690529081018290526060016040516020818303038152906040528051906020012060001c82828151811061164157634e487b7160e01b600052603260045260246000fd5b60209081029190910101528061165681612804565b9150506115ec565b5092915050565b6001600160a01b0384166116c55760405162461bcd60e51b815260206004820152602160248201527f455243313135353a206d696e7420746f20746865207a65726f206164647265736044820152607360f81b6064820152608401610473565b336116e5816000876116d688611d30565b6116df88611d30565b87611b6d565b6000848152602081815260408083206001600160a01b038916845290915281208054859290611715908490612729565b909155505060408051858152602081018590526001600160a01b0380881692600092918516917fc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62910160405180910390a46106b881600087878787611d89565b816001600160a01b0316836001600160a01b031614156117e95760405162461bcd60e51b815260206004820152602960248201527f455243313135353a2073657474696e6720617070726f76616c20737461747573604482015268103337b91039b2b63360b91b6064820152608401610473565b6001600160a01b03838116600081815260016020908152604080832094871680845294825291829020805460ff191686151590811790915591519182527f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a3505050565b6001600160a01b0384166118ba5760405162461bcd60e51b815260206004820152602560248201527f455243313135353a207472616e7366657220746f20746865207a65726f206164604482015264647265737360d81b6064820152608401610473565b336118ca8187876116d688611d30565b6000848152602081815260408083206001600160a01b038a1684529091529020548381101561194e5760405162461bcd60e51b815260206004820152602a60248201527f455243313135353a20696e73756666696369656e742062616c616e636520666f60448201526939103a3930b739b332b960b11b6064820152608401610473565b6000858152602081815260408083206001600160a01b038b811685529252808320878503905590881682528120805486929061198b908490612729565b909155505060408051868152602081018690526001600160a01b03808916928a821692918616917fc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62910160405180910390a46119eb828888888888611d89565b50505050505050565b6001600160a01b038316611a565760405162461bcd60e51b815260206004820152602360248201527f455243313135353a206275726e2066726f6d20746865207a65726f206164647260448201526265737360e81b6064820152608401610473565b33611a8581856000611a6787611d30565b611a7087611d30565b60405180602001604052806000815250611b6d565b6000838152602081815260408083206001600160a01b038816845290915290205482811015611b025760405162461bcd60e51b8152602060048201526024808201527f455243313135353a206275726e20616d6f756e7420657863656564732062616c604482015263616e636560e01b6064820152608401610473565b6000848152602081815260408083206001600160a01b03898116808652918452828520888703905582518981529384018890529092908616917fc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62910160405180910390a45050505050565b611246868686868686611e94565b6001600160a01b0384163b156112465760405163bc197c8160e01b81526001600160a01b0385169063bc197c8190611bbf9089908990889088908890600401612610565b602060405180830381600087803b158015611bd957600080fd5b505af1925050508015611c09575060408051601f3d908101601f19168201909252611c06918101906124c7565b60015b611cbf57611c15612875565b806308c379a01415611c4f5750611c2a61288d565b80611c355750611c51565b8060405162461bcd60e51b815260040161047391906126f2565b505b60405162461bcd60e51b815260206004820152603460248201527f455243313135353a207472616e7366657220746f206e6f6e204552433131353560448201527f526563656976657220696d706c656d656e7465720000000000000000000000006064820152608401610473565b6001600160e01b0319811663bc197c8160e01b146119eb5760405162461bcd60e51b815260206004820152602860248201527f455243313135353a204552433131353552656365697665722072656a656374656044820152676420746f6b656e7360c01b6064820152608401610473565b60408051600180825281830190925260609160009190602080830190803683370190505090508281600081518110611d7857634e487b7160e01b600052603260045260246000fd5b602090810291909101015292915050565b6001600160a01b0384163b156112465760405163f23a6e6160e01b81526001600160a01b0385169063f23a6e6190611dcd908990899088908890889060040161266e565b602060405180830381600087803b158015611de757600080fd5b505af1925050508015611e17575060408051601f3d908101601f19168201909252611e14918101906124c7565b60015b611e2357611c15612875565b6001600160e01b0319811663f23a6e6160e01b146119eb5760405162461bcd60e51b815260206004820152602860248201527f455243313135353a204552433131353552656365697665722072656a656374656044820152676420746f6b656e7360c01b6064820152608401610473565b6001600160a01b038516611f375760005b8351811015611f3557828181518110611ece57634e487b7160e01b600052603260045260246000fd5b602002602001015160036000868481518110611efa57634e487b7160e01b600052603260045260246000fd5b602002602001015181526020019081526020016000206000828254611f1f9190612729565b90915550611f2e905081612804565b9050611ea5565b505b6001600160a01b0384166112465760005b83518110156119eb57828181518110611f7157634e487b7160e01b600052603260045260246000fd5b602002602001015160036000868481518110611f9d57634e487b7160e01b600052603260045260246000fd5b602002602001015181526020019081526020016000206000828254611fc29190612755565b90915550611fd1905081612804565b9050611f48565b828054611fe49061279c565b90600052602060002090601f016020900481019282612006576000855561204c565b82601f1061201f57805160ff191683800117855561204c565b8280016001018555821561204c579182015b8281111561204c578251825591602001919060010190612031565b5061205892915061205c565b5090565b5b80821115612058576000815560010161205d565b600067ffffffffffffffff83111561208b5761208b61285f565b6040516120a2601f8501601f1916602001826127d7565b8091508381528484840111156120b757600080fd5b83836020830137600060208583010152509392505050565b80356001600160a01b03811681146120e657600080fd5b919050565b600082601f8301126120fb578081fd5b8135602061210882612705565b60405161211582826127d7565b8381528281019150858301600585901b87018401881015612134578586fd5b855b8581101561215257813584529284019290840190600101612136565b5090979650505050505050565b600082601f83011261216f578081fd5b61217e83833560208501612071565b9392505050565b600060208284031215612196578081fd5b61217e826120cf565b600080604083850312156121b1578081fd5b6121ba836120cf565b91506121c8602084016120cf565b90509250929050565b600080600080600060a086880312156121e8578081fd5b6121f1866120cf565b94506121ff602087016120cf565b9350604086013567ffffffffffffffff8082111561221b578283fd5b61222789838a016120eb565b9450606088013591508082111561223c578283fd5b61224889838a016120eb565b9350608088013591508082111561225d578283fd5b5061226a8882890161215f565b9150509295509295909350565b600080600080600060a0868803121561228e578081fd5b612297866120cf565b94506122a5602087016120cf565b93506040860135925060608601359150608086013567ffffffffffffffff8111156122ce578182fd5b61226a8882890161215f565b6000806000606084860312156122ee578283fd5b6122f7846120cf565b9250602084013567ffffffffffffffff80821115612313578384fd5b61231f878388016120eb565b93506040860135915080821115612334578283fd5b50612341868287016120eb565b9150509250925092565b6000806040838503121561235d578182fd5b612366836120cf565b91506020830135801515811461237a578182fd5b809150509250929050565b60008060408385031215612397578182fd5b6123a0836120cf565b946020939093013593505050565b6000806000606084860312156123c2578081fd5b6123cb846120cf565b95602085013595506040909401359392505050565b600080604083850312156123f2578182fd5b823567ffffffffffffffff80821115612409578384fd5b818501915085601f83011261241c578384fd5b8135602061242982612705565b60405161243682826127d7565b8381528281019150858301600585901b870184018b1015612455578889fd5b8896505b8487101561247e5761246a816120cf565b835260019690960195918301918301612459565b5096505086013592505080821115612494578283fd5b506124a1858286016120eb565b9150509250929050565b6000602082840312156124bc578081fd5b813561217e81612917565b6000602082840312156124d8578081fd5b815161217e81612917565b6000602082840312156124f4578081fd5b813567ffffffffffffffff81111561250a578182fd5b8201601f8101841361251a578182fd5b610fbe84823560208401612071565b60006020828403121561253a578081fd5b5035919050565b600060208284031215612552578081fd5b5051919050565b6000806040838503121561256b578182fd5b823591506121c8602084016120cf565b6000815180845260208085019450808401835b838110156125aa5781518752958201959082019060010161258e565b509495945050505050565b600081518084526125cd81602086016020860161276c565b601f01601f19169290920160200192915050565b600083516125f381846020880161276c565b83519083019061260781836020880161276c565b01949350505050565b60006001600160a01b03808816835280871660208401525060a0604083015261263c60a083018661257b565b828103606084015261264e818661257b565b9050828103608084015261266281856125b5565b98975050505050505050565b60006001600160a01b03808816835280871660208401525084604083015283606083015260a060808301526126a660a08301846125b5565b979650505050505050565b60208152600061217e602083018461257b565b6040815260006126d7604083018561257b565b82810360208401526126e9818561257b565b95945050505050565b60208152600061217e60208301846125b5565b600067ffffffffffffffff82111561271f5761271f61285f565b5060051b60200190565b6000821982111561273c5761273c612833565b500190565b60008261275057612750612849565b500490565b60008282101561276757612767612833565b500390565b60005b8381101561278757818101518382015260200161276f565b83811115612796576000848401525b50505050565b600181811c908216806127b057607f821691505b602082108114156127d157634e487b7160e01b600052602260045260246000fd5b50919050565b601f8201601f1916810167ffffffffffffffff811182821017156127fd576127fd61285f565b6040525050565b600060001982141561281857612818612833565b5060010190565b60008261282e5761282e612849565b500690565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052601260045260246000fd5b634e487b7160e01b600052604160045260246000fd5b600060033d111561288a57600481823e5160e01c5b90565b600060443d101561289b5790565b6040516003193d81016004833e81513d67ffffffffffffffff81602484011181841117156128cb57505050505090565b82850191508151818111156128e35750505050505090565b843d87010160208285010111156128fd5750505050505090565b61290c602082860101876127d7565b509095945050505050565b6001600160e01b03198116811461088457600080fdfea26469706673582212206c5d49de046d19bdc59e8905debc486e4d688c942665d9495a051cb80f2f73e964736f6c634300080400330000000000000000000000004e57a7ce50336fa69c25c86d32d541ae0b9fb235000000000000000000000000ba3369c01accaf86c773e7dd66e11a3708a34a4200000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000000b4144456c656d656e74616c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000341444500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

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

0000000000000000000000004e57a7ce50336fa69c25c86d32d541ae0b9fb235000000000000000000000000ba3369c01accaf86c773e7dd66e11a3708a34a4200000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000000b4144456c656d656e74616c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000341444500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _adBoosterPackAddress (address): 0x4e57a7CE50336FA69C25C86d32d541aE0B9fB235
Arg [1] : _adRandomizerAddress (address): 0xba3369C01acCAf86c773e7Dd66e11A3708a34a42
Arg [2] : _name (string): ADElemental
Arg [3] : _symbol (string): ADE
Arg [4] : _uri (string): 

-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 0000000000000000000000004e57a7ce50336fa69c25c86d32d541ae0b9fb235
Arg [1] : 000000000000000000000000ba3369c01accaf86c773e7dd66e11a3708a34a42
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [3] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [5] : 000000000000000000000000000000000000000000000000000000000000000b
Arg [6] : 4144456c656d656e74616c000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [8] : 4144450000000000000000000000000000000000000000000000000000000000
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000000

1333:4312:19:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2170:228:2;;;;;;:::i;:::-;;:::i;:::-;;;19406:25:22;;;19394:2;19379:18;2170:228:2;;;;;;;;1221:305;;;;;;:::i;:::-;;:::i;:::-;;;12162:14:22;;12155:22;12137:41;;12125:2;12110:18;1221:305:2;12092:92:22;1610:35:19;;1644:1;1610:35;;3879:81;;;:::i;:::-;;;;;;;:::i;4057:203::-;;;;;;:::i;:::-;;:::i;4045:430:2:-;;;;;;:::i;:::-;;:::i;:::-;;1531:32:19;;1562:1;1531:32;;1652:48;;1699:1;1652:48;;2555:508:2;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;886:120:6:-;;;;;;:::i;:::-;943:4;770:16;;;:12;:16;;;;;;-1:-1:-1;;;886:120:6;1762:35:19;;;;;-1:-1:-1;;;;;1762:35:19;;;;;;-1:-1:-1;;;;;9752:55:22;;;9734:74;;9722:2;9707:18;1762:35:19;9689:125:22;5212:97:19;;;;;;:::i;:::-;;:::i;1492:33::-;;1524:1;1492:33;;709:342:5;;;;;;:::i;:::-;;:::i;1668:101:0:-;;;:::i;1453:33:19:-;;1485:1;1453:33;;1036:85:0;1108:6;;-1:-1:-1;;;;;1108:6:0;1036:85;;2909:903:19;;;;;;:::i;:::-;;:::i;3966:85::-;;;:::i;3131:153:2:-;;;;;;:::i;:::-;;:::i;682:111:6:-;;;;;;:::i;:::-;744:7;770:16;;;:12;:16;;;;;;;682:111;5046:160:19;;;;;;:::i;:::-;;:::i;4876:164::-;;;;;;:::i;:::-;;:::i;3351:166:2:-;;;;;;:::i;:::-;-1:-1:-1;;;;;3473:27:2;;;3450:4;3473:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;3351:166;3584:389;;;;;;:::i;:::-;;:::i;1918:198:0:-;;;;;;:::i;:::-;;:::i;393:310:5:-;;;;;;:::i;:::-;;:::i;2170:228:2:-;2256:7;-1:-1:-1;;;;;2283:21:2;;2275:77;;;;-1:-1:-1;;;2275:77:2;;13445:2:22;2275:77:2;;;13427:21:22;13484:2;13464:18;;;13457:30;13523:34;13503:18;;;13496:62;-1:-1:-1;;;13574:18:22;;;13567:41;13625:19;;2275:77:2;;;;;;;;;-1:-1:-1;2369:9:2;:13;;;;;;;;;;;-1:-1:-1;;;;;2369:22:2;;;;;;;;;;;;2170:228::o;1221:305::-;1323:4;-1:-1:-1;;;;;;1358:41:2;;-1:-1:-1;;;1358:41:2;;:109;;-1:-1:-1;;;;;;;1415:52:2;;-1:-1:-1;;;1415:52:2;1358:109;:161;;;-1:-1:-1;;;;;;;;;;937:40:16;;;1483:36:2;1339:180;1221:305;-1:-1:-1;;1221:305:2:o;3879:81:19:-;3916:13;3948:5;3941:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3879:81;:::o;4057:203::-;943:4:6;770:16;;;:12;:16;;;;;;4113:13:19;;4138:41;;;;-1:-1:-1;;;4138:41:19;;15485:2:22;4138:41:19;;;15467:21:22;15524:2;15504:18;;;15497:30;15563:19;15543:18;;;15536:47;15600:18;;4138:41:19;15457:167:22;4138:41:19;4221:14;4231:3;4221:9;:14::i;:::-;4237;:3;:12;:14::i;:::-;4204:48;;;;;;;;;:::i;:::-;;;;;;;;;;;;;4190:63;;4057:203;;;:::o;4045:430:2:-;-1:-1:-1;;;;;4270:20:2;;719:10:13;4270:20:2;;:60;;-1:-1:-1;4294:36:2;4311:4;719:10:13;3351:166:2;:::i;4294:36::-;4249:157;;;;-1:-1:-1;;;4249:157:2;;15831:2:22;4249:157:2;;;15813:21:22;15870:2;15850:18;;;15843:30;15909:34;15889:18;;;15882:62;15980:20;15960:18;;;15953:48;16018:19;;4249:157:2;15803:240:22;4249:157:2;4416:52;4439:4;4445:2;4449:3;4454:7;4463:4;4416:22;:52::i;:::-;4045:430;;;;;:::o;2555:508::-;2706:16;2765:3;:10;2746:8;:15;:29;2738:83;;;;-1:-1:-1;;;2738:83:2;;18241:2:22;2738:83:2;;;18223:21:22;18280:2;18260:18;;;18253:30;18319:34;18299:18;;;18292:62;-1:-1:-1;;;18370:18:22;;;18363:39;18419:19;;2738:83:2;18213:231:22;2738:83:2;2832:30;2879:8;:15;2865:30;;;;;;-1:-1:-1;;;2865:30:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2865:30:2;;2832:63;;2911:9;2906:120;2930:8;:15;2926:1;:19;2906:120;;;2985:30;2995:8;3004:1;2995:11;;;;;;-1:-1:-1;;;2995:11:2;;;;;;;;;;;;;;;3008:3;3012:1;3008:6;;;;;;-1:-1:-1;;;3008:6:2;;;;;;;;;;;;;;;2985:9;:30::i;:::-;2966:13;2980:1;2966:16;;;;;;-1:-1:-1;;;2966:16:2;;;;;;;;;;;;;;;;;;:49;2947:3;;;:::i;:::-;;;2906:120;;;-1:-1:-1;3043:13:2;2555:508;-1:-1:-1;;;2555:508:2:o;5212:97:19:-;1108:6:0;;-1:-1:-1;;;;;1108:6:0;719:10:13;1248:23:0;1240:68;;;;-1:-1:-1;;;1240:68:0;;17065:2:22;1240:68:0;;;17047:21:22;;;17084:18;;;17077:30;17143:34;17123:18;;;17116:62;17195:18;;1240:68:0;17037:182:22;1240:68:0;5285:17:19::1;5293:8;5285:7;:17::i;:::-;5212:97:::0;:::o;709:342:5:-;-1:-1:-1;;;;;868:23:5;;719:10:13;868:23:5;;:66;;-1:-1:-1;895:39:5;912:7;719:10:13;3351:166:2;:::i;895:39:5:-;847:154;;;;-1:-1:-1;;;847:154:5;;14669:2:22;847:154:5;;;14651:21:22;14708:2;14688:18;;;14681:30;14747:34;14727:18;;;14720:62;-1:-1:-1;;;14798:18:22;;;14791:39;14847:19;;847:154:5;14641:231:22;847:154:5;1012:32;1023:7;1032:3;1037:6;1012:10;:32::i;:::-;709:342;;;:::o;1668:101:0:-;1108:6;;-1:-1:-1;;;;;1108:6:0;719:10:13;1248:23:0;1240:68;;;;-1:-1:-1;;;1240:68:0;;17065:2:22;1240:68:0;;;17047:21:22;;;17084:18;;;17077:30;17143:34;17123:18;;;17116:62;17195:18;;1240:68:0;17037:182:22;1240:68:0;1732:30:::1;1759:1;1732:18;:30::i;:::-;1668:101::o:0;2909:903:19:-;2022:20;;-1:-1:-1;;;;;2022:20:19;2008:10;:34;1987:117;;;;-1:-1:-1;;;1987:117:19;;17426:2:22;1987:117:19;;;17408:21:22;17465:2;17445:18;;;17438:30;17504:34;17484:18;;;17477:62;-1:-1:-1;;;17555:18:22;;;17548:34;17599:19;;1987:117:19;17398:226:22;1987:117:19;1699:1:::1;3041:29:::0;::::1;3017:21;3116:88;3150:9;3155:3:::0;3150:4:::1;:9::i;:::-;3177:13;3116:16;:88::i;:::-;3084:120;;3223:9;3218:578;3242:13;3238:1;:17;3218:578;;;3280:19;3320:3;3302:12;3315:1;3302:15;;;;;;-1:-1:-1::0;;;3302:15:19::1;;;;;;;;;;;;;;;:21;;;-1:-1:-1::0;;;3302:21:19::1;;;;;;;;;;3280:43;;3360:2;3346:11;:16;3342:440;;;3386:24;3392:3;1485:1;3404;3386:24;;;;;;;;;;;::::0;:5:::1;:24::i;:::-;3342:440;;;3453:2;3439:11;:16;3435:347;;;3479:24;3485:3;1524:1;3497::::0;3479:24:::1;;;;;;;;;;;::::0;:5:::1;:24::i;3435:347::-;3546:2;3532:11;:16;3528:254;;;3572:23;3578:3;1562:1;3589;3572:23;;;;;;;;;;;::::0;:5:::1;:23::i;3528:254::-;3638:2;3624:11;:16;3620:162;;;3664:26;3670:3;1603:1;3684;3664:26;;;;;;;;;;;::::0;:5:::1;:26::i;3620:162::-;3737:26;3743:3;1644:1;3757;3737:26;;;;;;;;;;;::::0;:5:::1;:26::i;:::-;-1:-1:-1::0;3257:3:19::1;;3218:578;;3966:85:::0;4005:13;4037:7;4030:14;;;;;:::i;3131:153:2:-;3225:52;719:10:13;3258:8:2;3268;3225:18;:52::i;:::-;3131:153;;:::o;5046:160:19:-;1108:6:0;;-1:-1:-1;;;;;1108:6:0;719:10:13;1248:23:0;1240:68;;;;-1:-1:-1;;;1240:68:0;;17065:2:22;1240:68:0;;;17047:21:22;;;17084:18;;;17077:30;17143:34;17123:18;;;17116:62;17195:18;;1240:68:0;17037:182:22;1240:68:0;5157:19:19::1;:42:::0;;-1:-1:-1;;;;;;5157:42:19::1;-1:-1:-1::0;;;;;5157:42:19;;;::::1;::::0;;;::::1;::::0;;5046:160::o;4876:164::-;1108:6:0;;-1:-1:-1;;;;;1108:6:0;719:10:13;1248:23:0;1240:68;;;;-1:-1:-1;;;1240:68:0;;17065:2:22;1240:68:0;;;17047:21:22;;;17084:18;;;17077:30;17143:34;17123:18;;;17116:62;17195:18;;1240:68:0;17037:182:22;1240:68:0;4989:20:19::1;:44:::0;;-1:-1:-1;;;;;;4989:44:19::1;-1:-1:-1::0;;;;;4989:44:19;;;::::1;::::0;;;::::1;::::0;;4876:164::o;3584:389:2:-;-1:-1:-1;;;;;3784:20:2;;719:10:13;3784:20:2;;:60;;-1:-1:-1;3808:36:2;3825:4;719:10:13;3351:166:2;:::i;3808:36::-;3763:148;;;;-1:-1:-1;;;3763:148:2;;14669:2:22;3763:148:2;;;14651:21:22;14708:2;14688:18;;;14681:30;14747:34;14727:18;;;14720:62;-1:-1:-1;;;14798:18:22;;;14791:39;14847:19;;3763:148:2;14641:231:22;3763:148:2;3921:45;3939:4;3945:2;3949;3953:6;3961:4;3921:17;:45::i;1918:198:0:-;1108:6;;-1:-1:-1;;;;;1108:6:0;719:10:13;1248:23:0;1240:68;;;;-1:-1:-1;;;1240:68:0;;17065:2:22;1240:68:0;;;17047:21:22;;;17084:18;;;17077:30;17143:34;17123:18;;;17116:62;17195:18;;1240:68:0;17037:182:22;1240:68:0;-1:-1:-1;;;;;2006:22:0;::::1;1998:73;;;::::0;-1:-1:-1;;;1998:73:0;;13857:2:22;1998:73:0::1;::::0;::::1;13839:21:22::0;13896:2;13876:18;;;13869:30;13935:34;13915:18;;;13908:62;-1:-1:-1;;;13986:18:22;;;13979:36;14032:19;;1998:73:0::1;13829:228:22::0;1998:73:0::1;2081:28;2100:8;2081:18;:28::i;393:310:5:-:0;-1:-1:-1;;;;;527:23:5;;719:10:13;527:23:5;;:66;;-1:-1:-1;554:39:5;571:7;719:10:13;3351:166:2;:::i;554:39:5:-;506:154;;;;-1:-1:-1;;;506:154:5;;14669:2:22;506:154:5;;;14651:21:22;14708:2;14688:18;;;14681:30;14747:34;14727:18;;;14720:62;-1:-1:-1;;;14798:18:22;;;14791:39;14847:19;;506:154:5;14641:231:22;506:154:5;671:25;677:7;686:2;690:5;671;:25::i;1925:103:2:-;1985:13;2017:4;2010:11;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1925:103;;;:::o;328:703:14:-;384:13;601:10;597:51;;-1:-1:-1;;627:10:14;;;;;;;;;;;;-1:-1:-1;;;627:10:14;;;;;328:703::o;597:51::-;672:5;657:12;711:75;718:9;;711:75;;743:8;;;;:::i;:::-;;-1:-1:-1;765:10:14;;-1:-1:-1;773:2:14;765:10;;:::i;:::-;;;711:75;;;795:19;827:6;817:17;;;;;;-1:-1:-1;;;817:17:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;817:17:14;;795:39;;844:150;851:10;;844:150;;877:11;887:1;877:11;;:::i;:::-;;-1:-1:-1;945:10:14;953:2;945:5;:10;:::i;:::-;932:24;;:2;:24;:::i;:::-;919:39;;902:6;909;902:14;;;;;;-1:-1:-1;;;902:14:14;;;;;;;;;;;;:56;;;;;;;;;;-1:-1:-1;972:11:14;981:2;972:11;;:::i;:::-;;;844:150;;;1017:6;328:703;-1:-1:-1;;;;328:703:14:o;6068:1045:2:-;6288:7;:14;6274:3;:10;:28;6266:81;;;;-1:-1:-1;;;6266:81:2;;18651:2:22;6266:81:2;;;18633:21:22;18690:2;18670:18;;;18663:30;18729:34;18709:18;;;18702:62;-1:-1:-1;;;18780:18:22;;;18773:38;18828:19;;6266:81:2;18623:230:22;6266:81:2;-1:-1:-1;;;;;6365:16:2;;6357:66;;;;-1:-1:-1;;;6357:66:2;;15079:2:22;6357:66:2;;;15061:21:22;15118:2;15098:18;;;15091:30;15157:34;15137:18;;;15130:62;-1:-1:-1;;;15208:18:22;;;15201:35;15253:19;;6357:66:2;15051:227:22;6357:66:2;719:10:13;6476:60:2;719:10:13;6507:4:2;6513:2;6517:3;6522:7;6531:4;6476:20;:60::i;:::-;6552:9;6547:411;6571:3;:10;6567:1;:14;6547:411;;;6602:10;6615:3;6619:1;6615:6;;;;;;-1:-1:-1;;;6615:6:2;;;;;;;;;;;;;;;6602:19;;6635:14;6652:7;6660:1;6652:10;;;;;;-1:-1:-1;;;6652:10:2;;;;;;;;;;;;;;;;;;;;6677:19;6699:13;;;;;;;;;;-1:-1:-1;;;;;6699:19:2;;;;;;;;;;;;6652:10;;-1:-1:-1;6740:21:2;;;;6732:76;;;;-1:-1:-1;;;6732:76:2;;16654:2:22;6732:76:2;;;16636:21:22;16693:2;16673:18;;;16666:30;16732:34;16712:18;;;16705:62;-1:-1:-1;;;16783:18:22;;;16776:40;16833:19;;6732:76:2;16626:232:22;6732:76:2;6850:9;:13;;;;;;;;;;;-1:-1:-1;;;;;6850:19:2;;;;;;;;;;6872:20;;;6850:42;;6920:17;;;;;;;:27;;6872:20;;6850:9;6920:27;;6872:20;;6920:27;:::i;:::-;;;;;;;;6547:411;;;6583:3;;;;:::i;:::-;;;6547:411;;;;7003:2;-1:-1:-1;;;;;6973:47:2;6997:4;-1:-1:-1;;;;;6973:47:2;6987:8;-1:-1:-1;;;;;6973:47:2;;7007:3;7012:7;6973:47;;;;;;;:::i;:::-;;;;;;;;7031:75;7067:8;7077:4;7083:2;7087:3;7092:7;7101:4;7031:35;:75::i;:::-;6068:1045;;;;;;:::o;7936:86::-;8002:13;;;;:4;;:13;;;;;:::i;11072:867::-;-1:-1:-1;;;;;11219:18:2;;11211:66;;;;-1:-1:-1;;;11211:66:2;;16250:2:22;11211:66:2;;;16232:21:22;16289:2;16269:18;;;16262:30;16328:34;16308:18;;;16301:62;-1:-1:-1;;;16379:18:22;;;16372:33;16422:19;;11211:66:2;16222:225:22;11211:66:2;11309:7;:14;11295:3;:10;:28;11287:81;;;;-1:-1:-1;;;11287:81:2;;18651:2:22;11287:81:2;;;18633:21:22;18690:2;18670:18;;;18663:30;18729:34;18709:18;;;18702:62;-1:-1:-1;;;18780:18:22;;;18773:38;18828:19;;11287:81:2;18623:230:22;11287:81:2;11379:16;719:10:13;11379:31:2;;11421:66;11442:8;11452:4;11466:1;11470:3;11475:7;11421:66;;;;;;;;;;;;:20;:66::i;:::-;11503:9;11498:364;11522:3;:10;11518:1;:14;11498:364;;;11553:10;11566:3;11570:1;11566:6;;;;;;-1:-1:-1;;;11566:6:2;;;;;;;;;;;;;;;11553:19;;11586:14;11603:7;11611:1;11603:10;;;;;;-1:-1:-1;;;11603:10:2;;;;;;;;;;;;;;;;;;;;11628:19;11650:13;;;;;;;;;;-1:-1:-1;;;;;11650:19:2;;;;;;;;;;;;11603:10;;-1:-1:-1;11691:21:2;;;;11683:70;;;;-1:-1:-1;;;11683:70:2;;14264:2:22;11683:70:2;;;14246:21:22;14303:2;14283:18;;;14276:30;14342:34;14322:18;;;14315:62;-1:-1:-1;;;14393:18:22;;;14386:34;14437:19;;11683:70:2;14236:226:22;11683:70:2;11795:9;:13;;;;;;;;;;;-1:-1:-1;;;;;11795:19:2;;;;;;;;;;11817:20;;11795:42;;11534:3;;;;:::i;:::-;;;;11498:364;;;;11915:1;-1:-1:-1;;;;;11877:55:2;11901:4;-1:-1:-1;;;;;11877:55:2;11891:8;-1:-1:-1;;;;;11877:55:2;;11919:3;11924:7;11877:55;;;;;;;:::i;:::-;;;;;;;;11072:867;;;;:::o;2270:187:0:-;2362:6;;;-1:-1:-1;;;;;2378:17:0;;;-1:-1:-1;;;;;;2378:17:0;;;;;;;2410:40;;2362:6;;;2378:17;2362:6;;2410:40;;2343:16;;2410:40;2270:187;;:::o;4685:124:19:-;4780:12;;:22;;-1:-1:-1;;;4780:22:19;;-1:-1:-1;;;;;9752:55:22;;;4780:22:19;;;9734:74:22;4735:19:19;;4780:12;;:17;;9707:18:22;;4780:22:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;4324:355::-;4429:31;4507:1;4493:16;;;;;;-1:-1:-1;;;4493:16:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4493:16:19;;4476:33;;4524:9;4519:123;4543:1;4539;:5;4519:123;;;4603:26;;;;;;19616:25:22;;;19657:18;;;19650:34;;;19589:18;;4603:26:19;;;;;;;;;;;;4593:37;;;;;;4585:46;;4565:14;4580:1;4565:17;;;;;;-1:-1:-1;;;4565:17:19;;;;;;;;;;;;;;;;;;:66;4546:3;;;;:::i;:::-;;;;4519:123;;;;4324:355;;;;:::o;8395:553:2:-;-1:-1:-1;;;;;8542:16:2;;8534:62;;;;-1:-1:-1;;;8534:62:2;;19060:2:22;8534:62:2;;;19042:21:22;19099:2;19079:18;;;19072:30;19138:34;19118:18;;;19111:62;-1:-1:-1;;;19189:18:22;;;19182:31;19230:19;;8534:62:2;19032:223:22;8534:62:2;719:10:13;8649:102:2;719:10:13;8607:16:2;8692:2;8696:21;8714:2;8696:17;:21::i;:::-;8719:25;8737:6;8719:17;:25::i;:::-;8746:4;8649:20;:102::i;:::-;8762:9;:13;;;;;;;;;;;-1:-1:-1;;;;;8762:17:2;;;;;;;;;:27;;8783:6;;8762:9;:27;;8783:6;;8762:27;:::i;:::-;;;;-1:-1:-1;;8804:52:2;;;19616:25:22;;;19672:2;19657:18;;19650:34;;;-1:-1:-1;;;;;8804:52:2;;;;8837:1;;8804:52;;;;;;19589:18:22;8804:52:2;;;;;;;8867:74;8898:8;8916:1;8920:2;8924;8928:6;8936:4;8867:30;:74::i;12074:323::-;12224:8;-1:-1:-1;;;;;12215:17:2;:5;-1:-1:-1;;;;;12215:17:2;;;12207:71;;;;-1:-1:-1;;;12207:71:2;;17831:2:22;12207:71:2;;;17813:21:22;17870:2;17850:18;;;17843:30;17909:34;17889:18;;;17882:62;-1:-1:-1;;;17960:18:22;;;17953:39;18009:19;;12207:71:2;17803:231:22;12207:71:2;-1:-1:-1;;;;;12288:25:2;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;12288:46:2;;;;;;;;;;12349:41;;12137::22;;;12349::2;;12110:18:22;12349:41:2;;;;;;;12074:323;;;:::o;4925:797::-;-1:-1:-1;;;;;5106:16:2;;5098:66;;;;-1:-1:-1;;;5098:66:2;;15079:2:22;5098:66:2;;;15061:21:22;15118:2;15098:18;;;15091:30;15157:34;15137:18;;;15130:62;-1:-1:-1;;;15208:18:22;;;15201:35;15253:19;;5098:66:2;15051:227:22;5098:66:2;719:10:13;5217:96:2;719:10:13;5248:4:2;5254:2;5258:21;5276:2;5258:17;:21::i;5217:96::-;5324:19;5346:13;;;;;;;;;;;-1:-1:-1;;;;;5346:19:2;;;;;;;;;;5383:21;;;;5375:76;;;;-1:-1:-1;;;5375:76:2;;16654:2:22;5375:76:2;;;16636:21:22;16693:2;16673:18;;;16666:30;16732:34;16712:18;;;16705:62;-1:-1:-1;;;16783:18:22;;;16776:40;16833:19;;5375:76:2;16626:232:22;5375:76:2;5485:9;:13;;;;;;;;;;;-1:-1:-1;;;;;5485:19:2;;;;;;;;;;5507:20;;;5485:42;;5547:17;;;;;;;:27;;5507:20;;5485:9;5547:27;;5507:20;;5547:27;:::i;:::-;;;;-1:-1:-1;;5590:46:2;;;19616:25:22;;;19672:2;19657:18;;19650:34;;;-1:-1:-1;;;;;5590:46:2;;;;;;;;;;;;;;19589:18:22;5590:46:2;;;;;;;5647:68;5678:8;5688:4;5694:2;5698;5702:6;5710:4;5647:30;:68::i;:::-;4925:797;;;;;;;:::o;10248:630::-;-1:-1:-1;;;;;10370:18:2;;10362:66;;;;-1:-1:-1;;;10362:66:2;;16250:2:22;10362:66:2;;;16232:21:22;16289:2;16269:18;;;16262:30;16328:34;16308:18;;;16301:62;-1:-1:-1;;;16379:18:22;;;16372:33;16422:19;;10362:66:2;16222:225:22;10362:66:2;719:10:13;10481:102:2;719:10:13;10512:4:2;10439:16;10530:21;10548:2;10530:17;:21::i;:::-;10553:25;10571:6;10553:17;:25::i;:::-;10481:102;;;;;;;;;;;;:20;:102::i;:::-;10594:19;10616:13;;;;;;;;;;;-1:-1:-1;;;;;10616:19:2;;;;;;;;;;10653:21;;;;10645:70;;;;-1:-1:-1;;;10645:70:2;;14264:2:22;10645:70:2;;;14246:21:22;14303:2;14283:18;;;14276:30;14342:34;14322:18;;;14315:62;-1:-1:-1;;;14393:18:22;;;14386:34;14437:19;;10645:70:2;14236:226:22;10645:70:2;10749:9;:13;;;;;;;;;;;-1:-1:-1;;;;;10749:19:2;;;;;;;;;;;;10771:20;;;10749:42;;10817:54;;19616:25:22;;;19657:18;;;19650:34;;;10749:19:2;;10817:54;;;;;;19589:18:22;10817:54:2;;;;;;;10248:630;;;;;:::o;5315:328:19:-;5570:66;5597:8;5607:4;5613:2;5617:3;5622:7;5631:4;5570:26;:66::i;14282:792:2:-;-1:-1:-1;;;;;14514:13:2;;1087:20:12;1133:8;14510:558:2;;14549:79;;-1:-1:-1;;;14549:79:2;;-1:-1:-1;;;;;14549:43:2;;;;;:79;;14593:8;;14603:4;;14609:3;;14614:7;;14623:4;;14549:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14549:79:2;;;;;;;;-1:-1:-1;;14549:79:2;;;;;;;;;;;;:::i;:::-;;;14545:513;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;14934:6;14927:14;;-1:-1:-1;;;14927:14:2;;;;;;;;:::i;14545:513::-;;;14981:62;;-1:-1:-1;;;14981:62:2;;12615:2:22;14981:62:2;;;12597:21:22;12654:2;12634:18;;;12627:30;12693:34;12673:18;;;12666:62;12764:22;12744:18;;;12737:50;12804:19;;14981:62:2;12587:242:22;14545:513:2;-1:-1:-1;;;;;;14707:60:2;;-1:-1:-1;;;14707:60:2;14703:157;;14791:50;;-1:-1:-1;;;14791:50:2;;13036:2:22;14791:50:2;;;13018:21:22;13075:2;13055:18;;;13048:30;13114:34;13094:18;;;13087:62;-1:-1:-1;;;13165:18:22;;;13158:38;13213:19;;14791:50:2;13008:230:22;15080:193:2;15199:16;;;15213:1;15199:16;;;;;;;;;15146;;15174:22;;15199:16;;;;;;;;;;;;-1:-1:-1;15199:16:2;15174:41;;15236:7;15225:5;15231:1;15225:8;;;;;;-1:-1:-1;;;15225:8:2;;;;;;;;;;;;;;;;;;:18;15261:5;15080:193;-1:-1:-1;;15080:193:2:o;13551:725::-;-1:-1:-1;;;;;13758:13:2;;1087:20:12;1133:8;13754:516:2;;13793:72;;-1:-1:-1;;;13793:72:2;;-1:-1:-1;;;;;13793:38:2;;;;;:72;;13832:8;;13842:4;;13848:2;;13852:6;;13860:4;;13793:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;13793:72:2;;;;;;;;-1:-1:-1;;13793:72:2;;;;;;;;;;;;:::i;:::-;;;13789:471;;;;:::i;:::-;-1:-1:-1;;;;;;13914:55:2;;-1:-1:-1;;;13914:55:2;13910:152;;13993:50;;-1:-1:-1;;;13993:50:2;;13036:2:22;13993:50:2;;;13018:21:22;13075:2;13055:18;;;13048:30;13114:34;13094:18;;;13087:62;-1:-1:-1;;;13165:18:22;;;13158:38;13213:19;;13993:50:2;13008:230:22;1076:634:6;-1:-1:-1;;;;;1388:18:6;;1384:156;;1427:9;1422:108;1446:3;:10;1442:1;:14;1422:108;;;1505:7;1513:1;1505:10;;;;;;-1:-1:-1;;;1505:10:6;;;;;;;;;;;;;;;1481:12;:20;1494:3;1498:1;1494:6;;;;;;-1:-1:-1;;;1494:6:6;;;;;;;;;;;;;;;1481:20;;;;;;;;;;;;:34;;;;;;;:::i;:::-;;;;-1:-1:-1;1458:3:6;;-1:-1:-1;1458:3:6;;:::i;:::-;;;1422:108;;;;1384:156;-1:-1:-1;;;;;1554:16:6;;1550:154;;1591:9;1586:108;1610:3;:10;1606:1;:14;1586:108;;;1669:7;1677:1;1669:10;;;;;;-1:-1:-1;;;1669:10:6;;;;;;;;;;;;;;;1645:12;:20;1658:3;1662:1;1658:6;;;;;;-1:-1:-1;;;1658:6:6;;;;;;;;;;;;;;;1645:20;;;;;;;;;;;;:34;;;;;;;:::i;:::-;;;;-1:-1:-1;1622:3:6;;-1:-1:-1;1622:3:6;;:::i;:::-;;;1586:108;;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:468:22;78:5;112:18;104:6;101:30;98:2;;;134:18;;:::i;:::-;183:2;177:9;195:69;252:2;231:15;;-1:-1:-1;;227:29:22;258:4;223:40;177:9;195:69;:::i;:::-;282:6;273:15;;312:6;304;297:22;352:3;343:6;338:3;334:16;331:25;328:2;;;369:1;366;359:12;328:2;419:6;414:3;407:4;399:6;395:17;382:44;474:1;467:4;458:6;450;446:19;442:30;435:41;;88:394;;;;;:::o;487:196::-;555:20;;-1:-1:-1;;;;;604:54:22;;594:65;;584:2;;673:1;670;663:12;584:2;536:147;;;:::o;688:755::-;742:5;795:3;788:4;780:6;776:17;772:27;762:2;;817:5;810;803:20;762:2;857:6;844:20;883:4;906:43;946:2;906:43;:::i;:::-;978:2;972:9;990:31;1018:2;1010:6;990:31;:::i;:::-;1056:18;;;1090:15;;;;-1:-1:-1;1125:15:22;;;1175:1;1171:10;;;1159:23;;1155:32;;1152:41;-1:-1:-1;1149:2:22;;;1210:5;1203;1196:20;1149:2;1236:5;1250:163;1264:2;1261:1;1258:9;1250:163;;;1321:17;;1309:30;;1359:12;;;;1391;;;;1282:1;1275:9;1250:163;;;-1:-1:-1;1431:6:22;;752:691;-1:-1:-1;;;;;;;752:691:22:o;1448:228::-;1490:5;1543:3;1536:4;1528:6;1524:17;1520:27;1510:2;;1565:5;1558;1551:20;1510:2;1591:79;1666:3;1657:6;1644:20;1637:4;1629:6;1625:17;1591:79;:::i;:::-;1582:88;1500:176;-1:-1:-1;;;1500:176:22:o;1681:196::-;1740:6;1793:2;1781:9;1772:7;1768:23;1764:32;1761:2;;;1814:6;1806;1799:22;1761:2;1842:29;1861:9;1842:29;:::i;1882:270::-;1950:6;1958;2011:2;1999:9;1990:7;1986:23;1982:32;1979:2;;;2032:6;2024;2017:22;1979:2;2060:29;2079:9;2060:29;:::i;:::-;2050:39;;2108:38;2142:2;2131:9;2127:18;2108:38;:::i;:::-;2098:48;;1969:183;;;;;:::o;2157:983::-;2311:6;2319;2327;2335;2343;2396:3;2384:9;2375:7;2371:23;2367:33;2364:2;;;2418:6;2410;2403:22;2364:2;2446:29;2465:9;2446:29;:::i;:::-;2436:39;;2494:38;2528:2;2517:9;2513:18;2494:38;:::i;:::-;2484:48;;2583:2;2572:9;2568:18;2555:32;2606:18;2647:2;2639:6;2636:14;2633:2;;;2668:6;2660;2653:22;2633:2;2696:61;2749:7;2740:6;2729:9;2725:22;2696:61;:::i;:::-;2686:71;;2810:2;2799:9;2795:18;2782:32;2766:48;;2839:2;2829:8;2826:16;2823:2;;;2860:6;2852;2845:22;2823:2;2888:63;2943:7;2932:8;2921:9;2917:24;2888:63;:::i;:::-;2878:73;;3004:3;2993:9;2989:19;2976:33;2960:49;;3034:2;3024:8;3021:16;3018:2;;;3055:6;3047;3040:22;3018:2;;3083:51;3126:7;3115:8;3104:9;3100:24;3083:51;:::i;:::-;3073:61;;;2354:786;;;;;;;;:::o;3145:626::-;3249:6;3257;3265;3273;3281;3334:3;3322:9;3313:7;3309:23;3305:33;3302:2;;;3356:6;3348;3341:22;3302:2;3384:29;3403:9;3384:29;:::i;:::-;3374:39;;3432:38;3466:2;3455:9;3451:18;3432:38;:::i;:::-;3422:48;;3517:2;3506:9;3502:18;3489:32;3479:42;;3568:2;3557:9;3553:18;3540:32;3530:42;;3623:3;3612:9;3608:19;3595:33;3651:18;3643:6;3640:30;3637:2;;;3688:6;3680;3673:22;3637:2;3716:49;3757:7;3748:6;3737:9;3733:22;3716:49;:::i;3776:699::-;3903:6;3911;3919;3972:2;3960:9;3951:7;3947:23;3943:32;3940:2;;;3993:6;3985;3978:22;3940:2;4021:29;4040:9;4021:29;:::i;:::-;4011:39;;4101:2;4090:9;4086:18;4073:32;4124:18;4165:2;4157:6;4154:14;4151:2;;;4186:6;4178;4171:22;4151:2;4214:61;4267:7;4258:6;4247:9;4243:22;4214:61;:::i;:::-;4204:71;;4328:2;4317:9;4313:18;4300:32;4284:48;;4357:2;4347:8;4344:16;4341:2;;;4378:6;4370;4363:22;4341:2;;4406:63;4461:7;4450:8;4439:9;4435:24;4406:63;:::i;:::-;4396:73;;;3930:545;;;;;:::o;4480:367::-;4545:6;4553;4606:2;4594:9;4585:7;4581:23;4577:32;4574:2;;;4627:6;4619;4612:22;4574:2;4655:29;4674:9;4655:29;:::i;:::-;4645:39;;4734:2;4723:9;4719:18;4706:32;4781:5;4774:13;4767:21;4760:5;4757:32;4747:2;;4808:6;4800;4793:22;4747:2;4836:5;4826:15;;;4564:283;;;;;:::o;4852:264::-;4920:6;4928;4981:2;4969:9;4960:7;4956:23;4952:32;4949:2;;;5002:6;4994;4987:22;4949:2;5030:29;5049:9;5030:29;:::i;:::-;5020:39;5106:2;5091:18;;;;5078:32;;-1:-1:-1;;;4939:177:22:o;5121:332::-;5198:6;5206;5214;5267:2;5255:9;5246:7;5242:23;5238:32;5235:2;;;5288:6;5280;5273:22;5235:2;5316:29;5335:9;5316:29;:::i;:::-;5306:39;5392:2;5377:18;;5364:32;;-1:-1:-1;5443:2:22;5428:18;;;5415:32;;5225:228;-1:-1:-1;;;5225:228:22:o;5458:1274::-;5576:6;5584;5637:2;5625:9;5616:7;5612:23;5608:32;5605:2;;;5658:6;5650;5643:22;5605:2;5703:9;5690:23;5732:18;5773:2;5765:6;5762:14;5759:2;;;5794:6;5786;5779:22;5759:2;5837:6;5826:9;5822:22;5812:32;;5882:7;5875:4;5871:2;5867:13;5863:27;5853:2;;5909:6;5901;5894:22;5853:2;5950;5937:16;5972:4;5995:43;6035:2;5995:43;:::i;:::-;6067:2;6061:9;6079:31;6107:2;6099:6;6079:31;:::i;:::-;6145:18;;;6179:15;;;;-1:-1:-1;6214:11:22;;;6256:1;6252:10;;;6244:19;;6240:28;;6237:41;-1:-1:-1;6234:2:22;;;6296:6;6288;6281:22;6234:2;6323:6;6314:15;;6338:169;6352:2;6349:1;6346:9;6338:169;;;6409:23;6428:3;6409:23;:::i;:::-;6397:36;;6370:1;6363:9;;;;;6453:12;;;;6485;;6338:169;;;-1:-1:-1;6526:6:22;-1:-1:-1;;6570:18:22;;6557:32;;-1:-1:-1;;6601:16:22;;;6598:2;;;6635:6;6627;6620:22;6598:2;;6663:63;6718:7;6707:8;6696:9;6692:24;6663:63;:::i;:::-;6653:73;;;5595:1137;;;;;:::o;6737:255::-;6795:6;6848:2;6836:9;6827:7;6823:23;6819:32;6816:2;;;6869:6;6861;6854:22;6816:2;6913:9;6900:23;6932:30;6956:5;6932:30;:::i;6997:259::-;7066:6;7119:2;7107:9;7098:7;7094:23;7090:32;7087:2;;;7140:6;7132;7125:22;7087:2;7177:9;7171:16;7196:30;7220:5;7196:30;:::i;7261:480::-;7330:6;7383:2;7371:9;7362:7;7358:23;7354:32;7351:2;;;7404:6;7396;7389:22;7351:2;7449:9;7436:23;7482:18;7474:6;7471:30;7468:2;;;7519:6;7511;7504:22;7468:2;7547:22;;7600:4;7592:13;;7588:27;-1:-1:-1;7578:2:22;;7634:6;7626;7619:22;7578:2;7662:73;7727:7;7722:2;7709:16;7704:2;7700;7696:11;7662:73;:::i;7746:190::-;7805:6;7858:2;7846:9;7837:7;7833:23;7829:32;7826:2;;;7879:6;7871;7864:22;7826:2;-1:-1:-1;7907:23:22;;7816:120;-1:-1:-1;7816:120:22:o;7941:194::-;8011:6;8064:2;8052:9;8043:7;8039:23;8035:32;8032:2;;;8085:6;8077;8070:22;8032:2;-1:-1:-1;8113:16:22;;8022:113;-1:-1:-1;8022:113:22:o;8140:264::-;8208:6;8216;8269:2;8257:9;8248:7;8244:23;8240:32;8237:2;;;8290:6;8282;8275:22;8237:2;8331:9;8318:23;8308:33;;8360:38;8394:2;8383:9;8379:18;8360:38;:::i;8409:437::-;8462:3;8500:5;8494:12;8527:6;8522:3;8515:19;8553:4;8582:2;8577:3;8573:12;8566:19;;8619:2;8612:5;8608:14;8640:3;8652:169;8666:6;8663:1;8660:13;8652:169;;;8727:13;;8715:26;;8761:12;;;;8796:15;;;;8688:1;8681:9;8652:169;;;-1:-1:-1;8837:3:22;;8470:376;-1:-1:-1;;;;;8470:376:22:o;8851:257::-;8892:3;8930:5;8924:12;8957:6;8952:3;8945:19;8973:63;9029:6;9022:4;9017:3;9013:14;9006:4;8999:5;8995:16;8973:63;:::i;:::-;9090:2;9069:15;-1:-1:-1;;9065:29:22;9056:39;;;;9097:4;9052:50;;8900:208;-1:-1:-1;;8900:208:22:o;9113:470::-;9292:3;9330:6;9324:13;9346:53;9392:6;9387:3;9380:4;9372:6;9368:17;9346:53;:::i;:::-;9462:13;;9421:16;;;;9484:57;9462:13;9421:16;9518:4;9506:17;;9484:57;:::i;:::-;9557:20;;9300:283;-1:-1:-1;;;;9300:283:22:o;9819:849::-;10141:4;-1:-1:-1;;;;;10251:2:22;10243:6;10239:15;10228:9;10221:34;10303:2;10295:6;10291:15;10286:2;10275:9;10271:18;10264:43;;10343:3;10338:2;10327:9;10323:18;10316:31;10370:57;10422:3;10411:9;10407:19;10399:6;10370:57;:::i;:::-;10475:9;10467:6;10463:22;10458:2;10447:9;10443:18;10436:50;10509:44;10546:6;10538;10509:44;:::i;:::-;10495:58;;10602:9;10594:6;10590:22;10584:3;10573:9;10569:19;10562:51;10630:32;10655:6;10647;10630:32;:::i;:::-;10622:40;10150:518;-1:-1:-1;;;;;;;;10150:518:22:o;10673:583::-;10895:4;-1:-1:-1;;;;;11005:2:22;10997:6;10993:15;10982:9;10975:34;11057:2;11049:6;11045:15;11040:2;11029:9;11025:18;11018:43;;11097:6;11092:2;11081:9;11077:18;11070:34;11140:6;11135:2;11124:9;11120:18;11113:34;11184:3;11178;11167:9;11163:19;11156:32;11205:45;11245:3;11234:9;11230:19;11222:6;11205:45;:::i;:::-;11197:53;10904:352;-1:-1:-1;;;;;;;10904:352:22:o;11261:261::-;11440:2;11429:9;11422:21;11403:4;11460:56;11512:2;11501:9;11497:18;11489:6;11460:56;:::i;11527:465::-;11784:2;11773:9;11766:21;11747:4;11810:56;11862:2;11851:9;11847:18;11839:6;11810:56;:::i;:::-;11914:9;11906:6;11902:22;11897:2;11886:9;11882:18;11875:50;11942:44;11979:6;11971;11942:44;:::i;:::-;11934:52;11756:236;-1:-1:-1;;;;;11756:236:22:o;12189:219::-;12338:2;12327:9;12320:21;12301:4;12358:44;12398:2;12387:9;12383:18;12375:6;12358:44;:::i;19695:183::-;19755:4;19788:18;19780:6;19777:30;19774:2;;;19810:18;;:::i;:::-;-1:-1:-1;19855:1:22;19851:14;19867:4;19847:25;;19764:114::o;19883:128::-;19923:3;19954:1;19950:6;19947:1;19944:13;19941:2;;;19960:18;;:::i;:::-;-1:-1:-1;19996:9:22;;19931:80::o;20016:120::-;20056:1;20082;20072:2;;20087:18;;:::i;:::-;-1:-1:-1;20121:9:22;;20062:74::o;20141:125::-;20181:4;20209:1;20206;20203:8;20200:2;;;20214:18;;:::i;:::-;-1:-1:-1;20251:9:22;;20190:76::o;20271:258::-;20343:1;20353:113;20367:6;20364:1;20361:13;20353:113;;;20443:11;;;20437:18;20424:11;;;20417:39;20389:2;20382:10;20353:113;;;20484:6;20481:1;20478:13;20475:2;;;20519:1;20510:6;20505:3;20501:16;20494:27;20475:2;;20324:205;;;:::o;20534:380::-;20613:1;20609:12;;;;20656;;;20677:2;;20731:4;20723:6;20719:17;20709:27;;20677:2;20784;20776:6;20773:14;20753:18;20750:38;20747:2;;;20830:10;20825:3;20821:20;20818:1;20811:31;20865:4;20862:1;20855:15;20893:4;20890:1;20883:15;20747:2;;20589:325;;;:::o;20919:249::-;21029:2;21010:13;;-1:-1:-1;;21006:27:22;20994:40;;21064:18;21049:34;;21085:22;;;21046:62;21043:2;;;21111:18;;:::i;:::-;21147:2;21140:22;-1:-1:-1;;20966:202:22:o;21173:135::-;21212:3;-1:-1:-1;;21233:17:22;;21230:2;;;21253:18;;:::i;:::-;-1:-1:-1;21300:1:22;21289:13;;21220:88::o;21313:112::-;21345:1;21371;21361:2;;21376:18;;:::i;:::-;-1:-1:-1;21410:9:22;;21351:74::o;21430:127::-;21491:10;21486:3;21482:20;21479:1;21472:31;21522:4;21519:1;21512:15;21546:4;21543:1;21536:15;21562:127;21623:10;21618:3;21614:20;21611:1;21604:31;21654:4;21651:1;21644:15;21678:4;21675:1;21668:15;21694:127;21755:10;21750:3;21746:20;21743:1;21736:31;21786:4;21783:1;21776:15;21810:4;21807:1;21800:15;21826:185;21861:3;21903:1;21885:16;21882:23;21879:2;;;21953:1;21948:3;21943;21928:27;21984:10;21979:3;21975:20;21879:2;21869:142;:::o;22016:671::-;22055:3;22097:4;22079:16;22076:26;22073:2;;;22063:624;:::o;22073:2::-;22139;22133:9;-1:-1:-1;;22204:16:22;22200:25;;22197:1;22133:9;22176:50;22255:4;22249:11;22279:16;22314:18;22385:2;22378:4;22370:6;22366:17;22363:25;22358:2;22350:6;22347:14;22344:45;22341:2;;;22392:5;;;;;22063:624;:::o;22341:2::-;22429:6;22423:4;22419:17;22408:28;;22465:3;22459:10;22492:2;22484:6;22481:14;22478:2;;;22498:5;;;;;;22063:624;:::o;22478:2::-;22582;22563:16;22557:4;22553:27;22549:36;22542:4;22533:6;22528:3;22524:16;22520:27;22517:69;22514:2;;;22589:5;;;;;;22063:624;:::o;22514:2::-;22605:57;22656:4;22647:6;22639;22635:19;22631:30;22625:4;22605:57;:::i;:::-;-1:-1:-1;22678:3:22;;22063:624;-1:-1:-1;;;;;22063:624:22:o;22692:131::-;-1:-1:-1;;;;;;22766:32:22;;22756:43;;22746:2;;22813:1;22810;22803:12

ipfs://6c5d49de046d19bdc59e8905debc486e4d688c942665d9495a051cb80f2f73e9