Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

//███    ██  ██████  ██████  ██     ██ ███████ ███████ ███████ 
//████   ██ ██    ██ ██   ██ ██     ██ ██      ██         ███  
//██ ██  ██ ██    ██ ██████  ██  █  ██ █████   █████     ███   
//██  ██ ██ ██    ██ ██   ██ ██ ███ ██ ██      ██       ███    
//██   ████  ██████  ██   ██  ███ ███  ███████ ███████ ███████ 

// @title: NORWEEZ
// @desc: 1st NFT Community Saving the Oceans & Seas an underwater metaverse 
// @url: http://norweez.com/
// @twitter: https://twitter.com/norweez
// @instagram: https://www.instagram.com/norweez                                                 
                                                            
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.2;
import './ERC721A.sol';
import './Ownable.sol';

contract Norweez is ERC721A, Ownable {  
    using Strings for uint256;
    string public _narwhalslink;
    uint256 public narwhals = 499;
    uint256 public max_per_wallet = 2;
   	constructor() ERC721A("Norweez", "NRWZ") {}

    address public a1;
    address public a2;
    address public a3;

    function setMaxperWallet(uint256 newLimit) public onlyOwner {
        max_per_wallet = newLimit;
    }

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

    function NarwhalLink(string memory parts) external onlyOwner {
        _narwhalslink = parts;
    }

    function norweezofOwner(address addr) public view returns(uint256[] memory) {
        uint256 tokenCount = balanceOf(addr);
        uint256[] memory tokensId = new uint256[](tokenCount);
        for(uint256 i; i < tokenCount; i++){
            tokensId[i] = tokenOfOwnerByIndex(addr, i);
        }
        return tokensId;
    }

    function mintNorweez(uint256 _amount) public payable {
        uint256 supply = totalSupply();
        require( _amount > 0 && _amount <= max_per_wallet, "Can only mint between 1 and 2 tokens at once" );
        require( supply + _amount <= narwhals,            "Can't mint more than max supply" );
        require((balanceOf(msg.sender) + _amount) <= max_per_wallet, "You exceed the Norweez minting per wallet");

        _safeMint(msg.sender, _amount);
    }

    function setTeamAddresses(address[] memory _a) public onlyOwner {
        a1 = _a[0];
        a2 = _a[1];
        a3 = _a[2];
    }

    function withdrawTeam(uint256 amount) public payable onlyOwner {
        uint256 percent = amount / 100;
        require(payable(a1).send(percent * 40));
        require(payable(a2).send(percent * 30));
        require(payable(a3).send(percent * 30));
    }
}

// SPDX-License-Identifier: MIT

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

    function _verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) private 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

pragma solidity ^0.8.0;

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

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

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

pragma solidity ^0.8.0;

import "./Strings.sol";

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

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

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

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

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

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

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

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

        return (signer, RecoverError.NoError);
    }

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

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

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

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

// SPDX-License-Identifier: MIT
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


pragma solidity ^0.8.0;
import "./Context.sol";
import "./ERC165.sol";
import "./IERC721.sol";
import "./IERC721Metadata.sol";
import "./IERC721Enumerable.sol";
import "./Address.sol";
import "./Strings.sol";
import "./IERC721Receiver.sol";


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
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

pragma solidity ^0.8.0;
import './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

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

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


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

pragma solidity ^0.8.0;
import './Context.sol';


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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_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 {
        _setOwner(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");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (finance/PaymentSplitter.sol)

pragma solidity ^0.8.0;
import './Context.sol';
import './Address.sol';



/**
 * @title PaymentSplitter
 * @dev This contract allows to split Ether payments among a group of accounts. The sender does not need to be aware
 * that the Ether will be split in this way, since it is handled transparently by the contract.
 *
 * The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each
 * account to a number of shares. Of all the Ether that this contract receives, each account will then be able to claim
 * an amount proportional to the percentage of total shares they were assigned.
 *
 * `PaymentSplitter` follows a _pull payment_ model. This means that payments are not automatically forwarded to the
 * accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}
 * function.
 *
 * NOTE: This contract assumes that ERC20 tokens will behave similarly to native tokens (Ether). Rebasing tokens, and
 * tokens that apply fees during transfers, are likely to not be supported as expected. If in doubt, we encourage you
 * to run tests before sending real value to this contract.
 */
contract Payment is Context {
    event PayeeAdded(address account, uint256 shares);
    event PaymentReleased(address to, uint256 amount);
    event PaymentReceived(address from, uint256 amount);

    uint256 private _totalShares;
    uint256 private _totalReleased;

    mapping(address => uint256) private _shares;
    mapping(address => uint256) private _released;
    address[] private _payees;

    /**
     * @dev Creates an instance of `PaymentSplitter` where each account in `payees` is assigned the number of shares at
     * the matching position in the `shares` array.
     *
     * All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no
     * duplicates in `payees`.
     */
    constructor(address[] memory payees, uint256[] memory shares_) payable {
        require(payees.length == shares_.length, "PaymentSplitter: payees and shares length mismatch");
        require(payees.length > 0, "PaymentSplitter: no payees");

        for (uint256 i = 0; i < payees.length; i++) {
            _addPayee(payees[i], shares_[i]);
        }
    }

    /**
     * @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully
     * reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the
     * reliability of the events, and not the actual splitting of Ether.
     *
     * To learn more about this see the Solidity documentation for
     * https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback
     * functions].
     */
    receive() external payable virtual {
        emit PaymentReceived(_msgSender(), msg.value);
    }

    /**
     * @dev Getter for the total shares held by payees.
     */
    function totalShares() public view returns (uint256) {
        return _totalShares;
    }

    /**
     * @dev Getter for the total amount of Ether already released.
     */
    function totalReleased() public view returns (uint256) {
        return _totalReleased;
    }


    /**
     * @dev Getter for the amount of shares held by an account.
     */
    function shares(address account) public view returns (uint256) {
        return _shares[account];
    }

    /**
     * @dev Getter for the amount of Ether already released to a payee.
     */
    function released(address account) public view returns (uint256) {
        return _released[account];
    }


    /**
     * @dev Getter for the address of the payee number `index`.
     */
    function payee(uint256 index) public view returns (address) {
        return _payees[index];
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
     * total shares and their previous withdrawals.
     */
    function release(address payable account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 totalReceived = address(this).balance + totalReleased();
        uint256 payment = _pendingPayment(account, totalReceived, released(account));

        require(payment != 0, "PaymentSplitter: account is not due payment");

        _released[account] += payment;
        _totalReleased += payment;

        Address.sendValue(account, payment);
        emit PaymentReleased(account, payment);
    }


    /**
     * @dev internal logic for computing the pending payment of an `account` given the token historical balances and
     * already released amounts.
     */
    function _pendingPayment(
        address account,
        uint256 totalReceived,
        uint256 alreadyReleased
    ) private view returns (uint256) {
        return (totalReceived * _shares[account]) / _totalShares - alreadyReleased;
    }

    /**
     * @dev Add a new payee to the contract.
     * @param account The address of the payee to add.
     * @param shares_ The number of shares owned by the payee.
     */
    function _addPayee(address account, uint256 shares_) private {
        require(account != address(0), "PaymentSplitter: account is the zero address");
        require(shares_ > 0, "PaymentSplitter: shares are 0");
        require(_shares[account] == 0, "PaymentSplitter: account already has shares");

        _payees.push(account);
        _shares[account] = shares_;
        _totalShares = _totalShares + shares_;
        emit PayeeAdded(account, shares_);
    }
}

// SPDX-License-Identifier: MIT

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"string","name":"parts","type":"string"}],"name":"NarwhalLink","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"_narwhalslink","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"a1","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"a2","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"a3","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"max_per_wallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mintNorweez","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"narwhals","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"norweezofOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newLimit","type":"uint256"}],"name":"setMaxperWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_a","type":"address[]"}],"name":"setTeamAddresses","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":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawTeam","outputs":[],"stateMutability":"payable","type":"function"}]

60806040526101f36009556002600a553480156200001c57600080fd5b5060408051808201825260078152662737b93bb2b2bd60c91b60208083019182528351808501909452600484526327292bad60e11b9084015281519192916200006891600191620000f7565b5080516200007e906002906020840190620000f7565b5050506200009b62000095620000a160201b60201c565b620000a5565b620001da565b3390565b600780546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b82805462000105906200019d565b90600052602060002090601f01602090048101928262000129576000855562000174565b82601f106200014457805160ff191683800117855562000174565b8280016001018555821562000174579182015b828111156200017457825182559160200191906001019062000157565b506200018292915062000186565b5090565b5b8082111562000182576000815560010162000187565b600181811c90821680620001b257607f821691505b60208210811415620001d457634e487b7160e01b600052602260045260246000fd5b50919050565b6121dd80620001ea6000396000f3fe6080604052600436106101d85760003560e01c8063715018a611610102578063b88d4fde11610095578063e985e9c511610064578063e985e9c514610536578063f2fde38b1461057f578063fd2b04921461059f578063fe625fb6146105b257600080fd5b8063b88d4fde146104c0578063c87b56dd146104e0578063cd3d444b14610500578063cf4593ba1461051657600080fd5b8063969e9d0c116100d1578063969e9d0c146104555780639957533814610475578063a22cb4651461048a578063ab53fcaa146104aa57600080fd5b8063715018a6146103ed5780638da5cb5b146104025780639426eef81461042057806395d89b411461044057600080fd5b806318160ddd1161017a5780634a2bbe3d116101495780634a2bbe3d1461036d5780634f6ccce71461038d5780636352211e146103ad57806370a08231146103cd57600080fd5b806318160ddd146102ee57806323b872dd1461030d5780632f745c591461032d57806342842e0e1461034d57600080fd5b8063081812fc116101b6578063081812fc14610261578063095ea7b3146102995780630f4bb4dc146102bb578063119552a1146102ce57600080fd5b806301ffc9a7146101dd57806304307fd71461021257806306fdde031461023f575b600080fd5b3480156101e957600080fd5b506101fd6101f8366004611b86565b6105d2565b60405190151581526020015b60405180910390f35b34801561021e57600080fd5b5061023261022d366004611bbf565b61063f565b6040516102099190611bda565b34801561024b57600080fd5b506102546106e1565b6040516102099190611c76565b34801561026d57600080fd5b5061028161027c366004611c89565b610773565b6040516001600160a01b039091168152602001610209565b3480156102a557600080fd5b506102b96102b4366004611ca2565b610803565b005b6102b96102c9366004611c89565b61091b565b3480156102da57600080fd5b50600b54610281906001600160a01b031681565b3480156102fa57600080fd5b506000545b604051908152602001610209565b34801561031957600080fd5b506102b9610328366004611ccc565b610a70565b34801561033957600080fd5b506102ff610348366004611ca2565b610a7b565b34801561035957600080fd5b506102b9610368366004611ccc565b610bd8565b34801561037957600080fd5b506102b9610388366004611c89565b610bf3565b34801561039957600080fd5b506102ff6103a8366004611c89565b610c22565b3480156103b957600080fd5b506102816103c8366004611c89565b610c84565b3480156103d957600080fd5b506102ff6103e8366004611bbf565b610c96565b3480156103f957600080fd5b506102b9610d27565b34801561040e57600080fd5b506007546001600160a01b0316610281565b34801561042c57600080fd5b50600d54610281906001600160a01b031681565b34801561044c57600080fd5b50610254610d5d565b34801561046157600080fd5b50600c54610281906001600160a01b031681565b34801561048157600080fd5b50610254610d6c565b34801561049657600080fd5b506102b96104a5366004611d08565b610dfa565b3480156104b657600080fd5b506102ff600a5481565b3480156104cc57600080fd5b506102b96104db366004611de3565b610ebf565b3480156104ec57600080fd5b506102546104fb366004611c89565b610ef8565b34801561050c57600080fd5b506102ff60095481565b34801561052257600080fd5b506102b9610531366004611e5f565b610fc6565b34801561054257600080fd5b506101fd610551366004611ea8565b6001600160a01b03918216600090815260066020908152604080832093909416825291909152205460ff1690565b34801561058b57600080fd5b506102b961059a366004611bbf565b611003565b6102b96105ad366004611c89565b61109e565b3480156105be57600080fd5b506102b96105cd366004611edb565b611186565b60006001600160e01b031982166380ac58cd60e01b148061060357506001600160e01b03198216635b5e139f60e01b145b8061061e57506001600160e01b0319821663780e9d6360e01b145b8061063957506301ffc9a760e01b6001600160e01b03198316145b92915050565b6060600061064c83610c96565b905060008167ffffffffffffffff81111561066957610669611d44565b604051908082528060200260200182016040528015610692578160200160208202803683370190505b50905060005b828110156106d9576106aa8582610a7b565b8282815181106106bc576106bc611f88565b6020908102919091010152806106d181611fb4565b915050610698565b509392505050565b6060600180546106f090611fcf565b80601f016020809104026020016040519081016040528092919081815260200182805461071c90611fcf565b80156107695780601f1061073e57610100808354040283529160200191610769565b820191906000526020600020905b81548152906001019060200180831161074c57829003601f168201915b5050505050905090565b6000610780826000541190565b6107e75760405162461bcd60e51b815260206004820152602d60248201527f455243373231413a20617070726f76656420717565727920666f72206e6f6e6560448201526c3c34b9ba32b73a103a37b5b2b760991b60648201526084015b60405180910390fd5b506000908152600560205260409020546001600160a01b031690565b600061080e82610c84565b9050806001600160a01b0316836001600160a01b0316141561087d5760405162461bcd60e51b815260206004820152602260248201527f455243373231413a20617070726f76616c20746f2063757272656e74206f776e60448201526132b960f11b60648201526084016107de565b336001600160a01b038216148061089957506108998133610551565b61090b5760405162461bcd60e51b815260206004820152603960248201527f455243373231413a20617070726f76652063616c6c6572206973206e6f74206f60448201527f776e6572206e6f7220617070726f76656420666f7220616c6c0000000000000060648201526084016107de565b610916838383611276565b505050565b600054811580159061092f5750600a548211155b6109905760405162461bcd60e51b815260206004820152602c60248201527f43616e206f6e6c79206d696e74206265747765656e203120616e64203220746f60448201526b6b656e73206174206f6e636560a01b60648201526084016107de565b60095461099d838361200a565b11156109eb5760405162461bcd60e51b815260206004820152601f60248201527f43616e2774206d696e74206d6f7265207468616e206d617820737570706c790060448201526064016107de565b600a54826109f833610c96565b610a02919061200a565b1115610a625760405162461bcd60e51b815260206004820152602960248201527f596f752065786365656420746865204e6f727765657a206d696e74696e672070604482015268195c881dd85b1b195d60ba1b60648201526084016107de565b610a6c33836112d2565b5050565b6109168383836112ec565b6000610a8683610c96565b8210610adf5760405162461bcd60e51b815260206004820152602260248201527f455243373231413a206f776e657220696e646578206f7574206f6620626f756e604482015261647360f01b60648201526084016107de565b600080549080805b83811015610b78576000818152600360209081526040918290208251808401909352546001600160a01b038116808452600160a01b90910467ffffffffffffffff169183019190915215610b3a57805192505b876001600160a01b0316836001600160a01b03161415610b6f5786841415610b685750935061063992505050565b6001909301925b50600101610ae7565b5060405162461bcd60e51b815260206004820152602e60248201527f455243373231413a20756e61626c6520746f2067657420746f6b656e206f662060448201526d0deeedccae440c4f240d2dcc8caf60931b60648201526084016107de565b61091683838360405180602001604052806000815250610ebf565b6007546001600160a01b03163314610c1d5760405162461bcd60e51b81526004016107de90612022565b600a55565b600080548210610c805760405162461bcd60e51b815260206004820152602360248201527f455243373231413a20676c6f62616c20696e646578206f7574206f6620626f756044820152626e647360e81b60648201526084016107de565b5090565b6000610c8f826115d1565b5192915050565b60006001600160a01b038216610d025760405162461bcd60e51b815260206004820152602b60248201527f455243373231413a2062616c616e636520717565727920666f7220746865207a60448201526a65726f206164647265737360a81b60648201526084016107de565b506001600160a01b03166000908152600460205260409020546001600160801b031690565b6007546001600160a01b03163314610d515760405162461bcd60e51b81526004016107de90612022565b610d5b60006116a8565b565b6060600280546106f090611fcf565b60088054610d7990611fcf565b80601f0160208091040260200160405190810160405280929190818152602001828054610da590611fcf565b8015610df25780601f10610dc757610100808354040283529160200191610df2565b820191906000526020600020905b815481529060010190602001808311610dd557829003601f168201915b505050505081565b6001600160a01b038216331415610e535760405162461bcd60e51b815260206004820152601a60248201527f455243373231413a20617070726f766520746f2063616c6c657200000000000060448201526064016107de565b3360008181526006602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b610eca8484846112ec565b610ed6848484846116fa565b610ef25760405162461bcd60e51b81526004016107de90612057565b50505050565b6060610f05826000541190565b610f695760405162461bcd60e51b815260206004820152602f60248201527f4552433732314d657461646174613a2055524920717565727920666f72206e6f60448201526e3732bc34b9ba32b73a103a37b5b2b760891b60648201526084016107de565b6000610f73611808565b9050805160001415610f945760405180602001604052806000815250610fbf565b80610f9e84611817565b604051602001610faf9291906120aa565b6040516020818303038152906040525b9392505050565b6007546001600160a01b03163314610ff05760405162461bcd60e51b81526004016107de90612022565b8051610a6c906008906020840190611ae0565b6007546001600160a01b0316331461102d5760405162461bcd60e51b81526004016107de90612022565b6001600160a01b0381166110925760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b60648201526084016107de565b61109b816116a8565b50565b6007546001600160a01b031633146110c85760405162461bcd60e51b81526004016107de90612022565b60006110d56064836120ef565b600b549091506001600160a01b03166108fc6110f2836028612103565b6040518115909202916000818181858888f1935050505061111257600080fd5b600c546001600160a01b03166108fc61112c83601e612103565b6040518115909202916000818181858888f1935050505061114c57600080fd5b600d546001600160a01b03166108fc61116683601e612103565b6040518115909202916000818181858888f19350505050610a6c57600080fd5b6007546001600160a01b031633146111b05760405162461bcd60e51b81526004016107de90612022565b806000815181106111c3576111c3611f88565b6020026020010151600b60006101000a8154816001600160a01b0302191690836001600160a01b031602179055508060018151811061120457611204611f88565b6020026020010151600c60006101000a8154816001600160a01b0302191690836001600160a01b031602179055508060028151811061124557611245611f88565b6020026020010151600d60006101000a8154816001600160a01b0302191690836001600160a01b0316021790555050565b60008281526005602052604080822080546001600160a01b0319166001600160a01b0387811691821790925591518593918516917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591a4505050565b610a6c828260405180602001604052806000815250611915565b60006112f7826115d1565b80519091506000906001600160a01b0316336001600160a01b0316148061132e57503361132384610773565b6001600160a01b0316145b80611340575081516113409033610551565b9050806113aa5760405162461bcd60e51b815260206004820152603260248201527f455243373231413a207472616e736665722063616c6c6572206973206e6f74206044820152711bdddb995c881b9bdc88185c1c1c9bdd995960721b60648201526084016107de565b846001600160a01b031682600001516001600160a01b03161461141e5760405162461bcd60e51b815260206004820152602660248201527f455243373231413a207472616e736665722066726f6d20696e636f72726563746044820152651037bbb732b960d11b60648201526084016107de565b6001600160a01b0384166114825760405162461bcd60e51b815260206004820152602560248201527f455243373231413a207472616e7366657220746f20746865207a65726f206164604482015264647265737360d81b60648201526084016107de565b6114926000848460000151611276565b6001600160a01b03858116600090815260046020908152604080832080546001600160801b03198082166001600160801b03928316600019018316179092558986168086528386208054938416938316600190810190931693909317909255888552600390935281842080546001600160e01b031916909117600160a01b4267ffffffffffffffff16021790559086018083529120549091166115875761153a816000541190565b15611587578251600082815260036020908152604090912080549186015167ffffffffffffffff16600160a01b026001600160e01b03199092166001600160a01b03909316929092171790555b5082846001600160a01b0316866001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a45b5050505050565b60408051808201909152600080825260208201526115f0826000541190565b61164f5760405162461bcd60e51b815260206004820152602a60248201527f455243373231413a206f776e657220717565727920666f72206e6f6e657869736044820152693a32b73a103a37b5b2b760b11b60648201526084016107de565b815b6000818152600360209081526040918290208251808401909352546001600160a01b038116808452600160a01b90910467ffffffffffffffff16918301919091521561169e579392505050565b5060001901611651565b600780546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b60006001600160a01b0384163b156117fc57604051630a85bd0160e11b81526001600160a01b0385169063150b7a029061173e903390899088908890600401612122565b602060405180830381600087803b15801561175857600080fd5b505af1925050508015611788575060408051601f3d908101601f191682019092526117859181019061215f565b60015b6117e2573d8080156117b6576040519150601f19603f3d011682016040523d82523d6000602084013e6117bb565b606091505b5080516117da5760405162461bcd60e51b81526004016107de90612057565b805181602001fd5b6001600160e01b031916630a85bd0160e11b149050611800565b5060015b949350505050565b6060600880546106f090611fcf565b60608161183b5750506040805180820190915260018152600360fc1b602082015290565b8160005b8115611865578061184f81611fb4565b915061185e9050600a836120ef565b915061183f565b60008167ffffffffffffffff81111561188057611880611d44565b6040519080825280601f01601f1916602001820160405280156118aa576020820181803683370190505b5090505b8415611800576118bf60018361217c565b91506118cc600a86612193565b6118d790603061200a565b60f81b8183815181106118ec576118ec611f88565b60200101906001600160f81b031916908160001a90535061190e600a866120ef565b94506118ae565b61091683838360016000546001600160a01b0385166119805760405162461bcd60e51b815260206004820152602160248201527f455243373231413a206d696e7420746f20746865207a65726f206164647265736044820152607360f81b60648201526084016107de565b836119de5760405162461bcd60e51b815260206004820152602860248201527f455243373231413a207175616e74697479206d75737420626520677265617465604482015267072207468616e20360c41b60648201526084016107de565b6001600160a01b03851660008181526004602090815260408083208054600160801b6001600160801b031982166001600160801b039283168c01831690811782900483168c01909216021790558483526003909152812080546001600160e01b031916909217600160a01b4267ffffffffffffffff16021790915581905b85811015611ad75760405182906001600160a01b038916906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a48315611acb57611aaf60008884886116fa565b611acb5760405162461bcd60e51b81526004016107de90612057565b60019182019101611a5c565b506000556115ca565b828054611aec90611fcf565b90600052602060002090601f016020900481019282611b0e5760008555611b54565b82601f10611b2757805160ff1916838001178555611b54565b82800160010185558215611b54579182015b82811115611b54578251825591602001919060010190611b39565b50610c809291505b80821115610c805760008155600101611b5c565b6001600160e01b03198116811461109b57600080fd5b600060208284031215611b9857600080fd5b8135610fbf81611b70565b80356001600160a01b0381168114611bba57600080fd5b919050565b600060208284031215611bd157600080fd5b610fbf82611ba3565b6020808252825182820181905260009190848201906040850190845b81811015611c1257835183529284019291840191600101611bf6565b50909695505050505050565b60005b83811015611c39578181015183820152602001611c21565b83811115610ef25750506000910152565b60008151808452611c62816020860160208601611c1e565b601f01601f19169290920160200192915050565b602081526000610fbf6020830184611c4a565b600060208284031215611c9b57600080fd5b5035919050565b60008060408385031215611cb557600080fd5b611cbe83611ba3565b946020939093013593505050565b600080600060608486031215611ce157600080fd5b611cea84611ba3565b9250611cf860208501611ba3565b9150604084013590509250925092565b60008060408385031215611d1b57600080fd5b611d2483611ba3565b915060208301358015158114611d3957600080fd5b809150509250929050565b634e487b7160e01b600052604160045260246000fd5b604051601f8201601f1916810167ffffffffffffffff81118282101715611d8357611d83611d44565b604052919050565b600067ffffffffffffffff831115611da557611da5611d44565b611db8601f8401601f1916602001611d5a565b9050828152838383011115611dcc57600080fd5b828260208301376000602084830101529392505050565b60008060008060808587031215611df957600080fd5b611e0285611ba3565b9350611e1060208601611ba3565b925060408501359150606085013567ffffffffffffffff811115611e3357600080fd5b8501601f81018713611e4457600080fd5b611e5387823560208401611d8b565b91505092959194509250565b600060208284031215611e7157600080fd5b813567ffffffffffffffff811115611e8857600080fd5b8201601f81018413611e9957600080fd5b61180084823560208401611d8b565b60008060408385031215611ebb57600080fd5b611ec483611ba3565b9150611ed260208401611ba3565b90509250929050565b60006020808385031215611eee57600080fd5b823567ffffffffffffffff80821115611f0657600080fd5b818501915085601f830112611f1a57600080fd5b813581811115611f2c57611f2c611d44565b8060051b9150611f3d848301611d5a565b8181529183018401918481019088841115611f5757600080fd5b938501935b83851015611f7c57611f6d85611ba3565b82529385019390850190611f5c565b98975050505050505050565b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052601160045260246000fd5b6000600019821415611fc857611fc8611f9e565b5060010190565b600181811c90821680611fe357607f821691505b6020821081141561200457634e487b7160e01b600052602260045260246000fd5b50919050565b6000821982111561201d5761201d611f9e565b500190565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b60208082526033908201527f455243373231413a207472616e7366657220746f206e6f6e204552433732315260408201527232b1b2b4bb32b91034b6b83632b6b2b73a32b960691b606082015260800190565b600083516120bc818460208801611c1e565b8351908301906120d0818360208801611c1e565b01949350505050565b634e487b7160e01b600052601260045260246000fd5b6000826120fe576120fe6120d9565b500490565b600081600019048311821515161561211d5761211d611f9e565b500290565b6001600160a01b038581168252841660208201526040810183905260806060820181905260009061215590830184611c4a565b9695505050505050565b60006020828403121561217157600080fd5b8151610fbf81611b70565b60008282101561218e5761218e611f9e565b500390565b6000826121a2576121a26120d9565b50069056fea2646970667358221220c69c0bccbf5679c36f0ef3d570ad360057705a1cc4cc34b1883231c778747cc164736f6c63430008090033

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

1097:1829:10:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3184:366:4;;;;;;;;;;-1:-1:-1;3184:366:4;;;;;:::i;:::-;;:::i;:::-;;;565:14:14;;558:22;540:41;;528:2;513:18;3184:366:4;;;;;;;;1730:328:10;;;;;;;;;;-1:-1:-1;1730:328:10;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;5020:98:4:-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;6534:210::-;;;;;;;;;;-1:-1:-1;6534:210:4;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2698:32:14;;;2680:51;;2668:2;2653:18;6534:210:4;2534:203:14;6070:403:4;;;;;;;;;;-1:-1:-1;6070:403:4;;;;;:::i;:::-;;:::i;:::-;;2064:460:10;;;;;;:::i;:::-;;:::i;1329:17::-;;;;;;;;;;-1:-1:-1;1329:17:10;;;;-1:-1:-1;;;;;1329:17:10;;;1486:98:4;;;;;;;;;;-1:-1:-1;1539:7:4;1565:12;1486:98;;;3147:25:14;;;3135:2;3120:18;1486:98:4;3001:177:14;7384:156:4;;;;;;;;;;-1:-1:-1;7384:156:4;;;;;:::i;:::-;;:::i;2133:984::-;;;;;;;;;;-1:-1:-1;2133:984:4;;;;;:::i;:::-;;:::i;7606:171::-;;;;;;;;;;-1:-1:-1;7606:171:4;;;;;:::i;:::-;;:::i;1399:102:10:-;;;;;;;;;;-1:-1:-1;1399:102:10;;;;;:::i;:::-;;:::i;1656:184:4:-;;;;;;;;;;-1:-1:-1;1656:184:4;;;;;:::i;:::-;;:::i;4836:122::-;;;;;;;;;;-1:-1:-1;4836:122:4;;;;;:::i;:::-;;:::i;3609:218::-;;;;;;;;;;-1:-1:-1;3609:218:4;;;;;:::i;:::-;;:::i;1598:92:11:-;;;;;;;;;;;;;:::i;966:85::-;;;;;;;;;;-1:-1:-1;1038:6:11;;-1:-1:-1;;;;;1038:6:11;966:85;;1375:17:10;;;;;;;;;;-1:-1:-1;1375:17:10;;;;-1:-1:-1;;;;;1375:17:10;;;5182:102:4;;;;;;;;;;;;;:::i;1352:17:10:-;;;;;;;;;;-1:-1:-1;1352:17:10;;;;-1:-1:-1;;;;;1352:17:10;;;1173:27;;;;;;;;;;;;;:::i;6811:283:4:-;;;;;;;;;;-1:-1:-1;6811:283:4;;;;;:::i;:::-;;:::i;1241:33:10:-;;;;;;;;;;;;;;;;7843:344:4;;;;;;;;;;-1:-1:-1;7843:344:4;;;;;:::i;:::-;;:::i;5350:330::-;;;;;;;;;;-1:-1:-1;5350:330:4;;;;;:::i;:::-;;:::i;1206:29:10:-;;;;;;;;;;;;;;;;1625:99;;;;;;;;;;-1:-1:-1;1625:99:10;;;;;:::i;:::-;;:::i;7160:162:4:-;;;;;;;;;;-1:-1:-1;7160:162:4;;;;;:::i;:::-;-1:-1:-1;;;;;7280:25:4;;;7257:4;7280:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;7160:162;1839:189:11;;;;;;;;;;-1:-1:-1;1839:189:11;;;;;:::i;:::-;;:::i;2667:257:10:-;;;;;;:::i;:::-;;:::i;2530:131::-;;;;;;;;;;-1:-1:-1;2530:131:10;;;;;:::i;:::-;;:::i;3184:366:4:-;3286:4;-1:-1:-1;;;;;;3321:40:4;;-1:-1:-1;;;3321:40:4;;:104;;-1:-1:-1;;;;;;;3377:48:4;;-1:-1:-1;;;3377:48:4;3321:104;:170;;;-1:-1:-1;;;;;;;3441:50:4;;-1:-1:-1;;;3441:50:4;3321:170;:222;;;-1:-1:-1;;;;;;;;;;869:40:3;;;3507:36:4;3302:241;3184:366;-1:-1:-1;;3184:366:4:o;1730:328:10:-;1788:16;1816:18;1837:15;1847:4;1837:9;:15::i;:::-;1816:36;;1862:25;1904:10;1890:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1890:25:10;;1862:53;;1929:9;1925:102;1944:10;1940:1;:14;1925:102;;;1988:28;2008:4;2014:1;1988:19;:28::i;:::-;1974:8;1983:1;1974:11;;;;;;;;:::i;:::-;;;;;;;;;;:42;1956:3;;;;:::i;:::-;;;;1925:102;;;-1:-1:-1;2043:8:10;1730:328;-1:-1:-1;;;1730:328:10:o;5020:98:4:-;5074:13;5106:5;5099:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5020:98;:::o;6534:210::-;6602:7;6629:16;6637:7;8490:4;8523:12;-1:-1:-1;8513:22:4;8433:109;6629:16;6621:74;;;;-1:-1:-1;;;6621:74:4;;8030:2:14;6621:74:4;;;8012:21:14;8069:2;8049:18;;;8042:30;8108:34;8088:18;;;8081:62;-1:-1:-1;;;8159:18:14;;;8152:43;8212:19;;6621:74:4;;;;;;;;;-1:-1:-1;6713:24:4;;;;:15;:24;;;;;;-1:-1:-1;;;;;6713:24:4;;6534:210::o;6070:403::-;6142:13;6158:24;6174:7;6158:15;:24::i;:::-;6142:40;;6206:5;-1:-1:-1;;;;;6200:11:4;:2;-1:-1:-1;;;;;6200:11:4;;;6192:58;;;;-1:-1:-1;;;6192:58:4;;8444:2:14;6192:58:4;;;8426:21:14;8483:2;8463:18;;;8456:30;8522:34;8502:18;;;8495:62;-1:-1:-1;;;8573:18:14;;;8566:32;8615:19;;6192:58:4;8242:398:14;6192:58:4;666:10:1;-1:-1:-1;;;;;6282:21:4;;;;:62;;-1:-1:-1;6307:37:4;6324:5;666:10:1;7160:162:4;:::i;6307:37::-;6261:166;;;;-1:-1:-1;;;6261:166:4;;8847:2:14;6261:166:4;;;8829:21:14;8886:2;8866:18;;;8859:30;8925:34;8905:18;;;8898:62;8996:27;8976:18;;;8969:55;9041:19;;6261:166:4;8645:421:14;6261:166:4;6438:28;6447:2;6451:7;6460:5;6438:8;:28::i;:::-;6132:341;6070:403;;:::o;2064:460:10:-;2127:14;1565:12:4;2176:11:10;;;;;:40;;;2202:14;;2191:7;:25;;2176:40;2167:99;;;;-1:-1:-1;;;2167:99:10;;9273:2:14;2167:99:10;;;9255:21:14;9312:2;9292:18;;;9285:30;9351:34;9331:18;;;9324:62;-1:-1:-1;;;9402:18:14;;;9395:42;9454:19;;2167:99:10;9071:408:14;2167:99:10;2305:8;;2285:16;2294:7;2285:6;:16;:::i;:::-;:28;;2276:85;;;;-1:-1:-1;;;2276:85:10;;9819:2:14;2276:85:10;;;9801:21:14;9858:2;9838:18;;;9831:30;9897:33;9877:18;;;9870:61;9948:18;;2276:85:10;9617:355:14;2276:85:10;2416:14;;2404:7;2380:21;2390:10;2380:9;:21::i;:::-;:31;;;;:::i;:::-;2379:51;;2371:105;;;;-1:-1:-1;;;2371:105:10;;10179:2:14;2371:105:10;;;10161:21:14;10218:2;10198:18;;;10191:30;10257:34;10237:18;;;10230:62;-1:-1:-1;;;10308:18:14;;;10301:39;10357:19;;2371:105:10;9977:405:14;2371:105:10;2487:30;2497:10;2509:7;2487:9;:30::i;:::-;2117:407;2064:460;:::o;7384:156:4:-;7505:28;7515:4;7521:2;7525:7;7505:9;:28::i;2133:984::-;2222:7;2257:16;2267:5;2257:9;:16::i;:::-;2249:5;:24;2241:71;;;;-1:-1:-1;;;2241:71:4;;10589:2:14;2241:71:4;;;10571:21:14;10628:2;10608:18;;;10601:30;10667:34;10647:18;;;10640:62;-1:-1:-1;;;10718:18:14;;;10711:32;10760:19;;2241:71:4;10387:398:14;2241:71:4;2322:22;1565:12;;;2322:22;;2579:455;2599:14;2595:1;:18;2579:455;;;2638:31;2672:14;;;:11;:14;;;;;;;;;2638:48;;;;;;;;;-1:-1:-1;;;;;2638:48:4;;;;;-1:-1:-1;;;2638:48:4;;;;;;;;;;;;2708:28;2704:109;;2780:14;;;-1:-1:-1;2704:109:4;2855:5;-1:-1:-1;;;;;2834:26:4;:17;-1:-1:-1;;;;;2834:26:4;;2830:190;;;2903:5;2888:11;:20;2884:83;;;-1:-1:-1;2943:1:4;-1:-1:-1;2936:8:4;;-1:-1:-1;;;2936:8:4;2884:83;2988:13;;;;;2830:190;-1:-1:-1;2615:3:4;;2579:455;;;-1:-1:-1;3054:56:4;;-1:-1:-1;;;3054:56:4;;10992:2:14;3054:56:4;;;10974:21:14;11031:2;11011:18;;;11004:30;11070:34;11050:18;;;11043:62;-1:-1:-1;;;11121:18:14;;;11114:44;11175:19;;3054:56:4;10790:410:14;7606:171:4;7731:39;7748:4;7754:2;7758:7;7731:39;;;;;;;;;;;;:16;:39::i;1399:102:10:-;1038:6:11;;-1:-1:-1;;;;;1038:6:11;666:10:1;1178:23:11;1170:68;;;;-1:-1:-1;;;1170:68:11;;;;;;;:::i;:::-;1469:14:10::1;:25:::0;1399:102::o;1656:184:4:-;1723:7;1565:12;;1750:5;:21;1742:69;;;;-1:-1:-1;;;1742:69:4;;11768:2:14;1742:69:4;;;11750:21:14;11807:2;11787:18;;;11780:30;11846:34;11826:18;;;11819:62;-1:-1:-1;;;11897:18:14;;;11890:33;11940:19;;1742:69:4;11566:399:14;1742:69:4;-1:-1:-1;1828:5:4;1656:184::o;4836:122::-;4900:7;4926:20;4938:7;4926:11;:20::i;:::-;:25;;4836:122;-1:-1:-1;;4836:122:4:o;3609:218::-;3673:7;-1:-1:-1;;;;;3700:19:4;;3692:75;;;;-1:-1:-1;;;3692:75:4;;12172:2:14;3692:75:4;;;12154:21:14;12211:2;12191:18;;;12184:30;12250:34;12230:18;;;12223:62;-1:-1:-1;;;12301:18:14;;;12294:41;12352:19;;3692:75:4;11970:407:14;3692:75:4;-1:-1:-1;;;;;;3792:19:4;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;3792:27:4;;3609:218::o;1598:92:11:-;1038:6;;-1:-1:-1;;;;;1038:6:11;666:10:1;1178:23:11;1170:68;;;;-1:-1:-1;;;1170:68:11;;;;;;;:::i;:::-;1662:21:::1;1680:1;1662:9;:21::i;:::-;1598:92::o:0;5182:102:4:-;5238:13;5270:7;5263:14;;;;;:::i;1173:27:10:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;6811:283:4:-;-1:-1:-1;;;;;6905:24:4;;666:10:1;6905:24:4;;6897:63;;;;-1:-1:-1;;;6897:63:4;;12584:2:14;6897:63:4;;;12566:21:14;12623:2;12603:18;;;12596:30;12662:28;12642:18;;;12635:56;12708:18;;6897:63:4;12382:350:14;6897:63:4;666:10:1;6971:32:4;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;6971:42:4;;;;;;;;;;;;:53;;-1:-1:-1;;6971:53:4;;;;;;;;;;7039:48;;540:41:14;;;6971:42:4;;666:10:1;7039:48:4;;513:18:14;7039:48:4;;;;;;;6811:283;;:::o;7843:344::-;7996:28;8006:4;8012:2;8016:7;7996:9;:28::i;:::-;8055:48;8078:4;8084:2;8088:7;8097:5;8055:22;:48::i;:::-;8034:146;;;;-1:-1:-1;;;8034:146:4;;;;;;;:::i;:::-;7843:344;;;;:::o;5350:330::-;5423:13;5456:16;5464:7;8490:4;8523:12;-1:-1:-1;8513:22:4;8433:109;5456:16;5448:76;;;;-1:-1:-1;;;5448:76:4;;13359:2:14;5448:76:4;;;13341:21:14;13398:2;13378:18;;;13371:30;13437:34;13417:18;;;13410:62;-1:-1:-1;;;13488:18:14;;;13481:45;13543:19;;5448:76:4;13157:411:14;5448:76:4;5535:21;5559:10;:8;:10::i;:::-;5535:34;;5592:7;5586:21;5611:1;5586:26;;:87;;;;;;;;;;;;;;;;;5639:7;5648:18;:7;:16;:18::i;:::-;5622:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;5586:87;5579:94;5350:330;-1:-1:-1;;;5350:330:4:o;1625:99:10:-;1038:6:11;;-1:-1:-1;;;;;1038:6:11;666:10:1;1178:23:11;1170:68;;;;-1:-1:-1;;;1170:68:11;;;;;;;:::i;:::-;1696:21:10;;::::1;::::0;:13:::1;::::0;:21:::1;::::0;::::1;::::0;::::1;:::i;1839:189:11:-:0;1038:6;;-1:-1:-1;;;;;1038:6:11;666:10:1;1178:23:11;1170:68;;;;-1:-1:-1;;;1170:68:11;;;;;;;:::i;:::-;-1:-1:-1;;;;;1927:22:11;::::1;1919:73;;;::::0;-1:-1:-1;;;1919:73:11;;14250:2:14;1919:73:11::1;::::0;::::1;14232:21:14::0;14289:2;14269:18;;;14262:30;14328:34;14308:18;;;14301:62;-1:-1:-1;;;14379:18:14;;;14372:36;14425:19;;1919:73:11::1;14048:402:14::0;1919:73:11::1;2002:19;2012:8;2002:9;:19::i;:::-;1839:189:::0;:::o;2667:257:10:-;1038:6:11;;-1:-1:-1;;;;;1038:6:11;666:10:1;1178:23:11;1170:68;;;;-1:-1:-1;;;1170:68:11;;;;;;;:::i;:::-;2740:15:10::1;2758:12;2767:3;2758:6:::0;:12:::1;:::i;:::-;2796:2;::::0;2740:30;;-1:-1:-1;;;;;;2796:2:10::1;2788:30;2805:12;2740:30:::0;2815:2:::1;2805:12;:::i;:::-;2788:30;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;::::1;;;;;;2780:39;;;::::0;::::1;;2845:2;::::0;-1:-1:-1;;;;;2845:2:10::1;2837:30;2854:12;:7:::0;2864:2:::1;2854:12;:::i;:::-;2837:30;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;::::1;;;;;;2829:39;;;::::0;::::1;;2894:2;::::0;-1:-1:-1;;;;;2894:2:10::1;2886:30;2903:12;:7:::0;2913:2:::1;2903:12;:::i;:::-;2886:30;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;::::1;;;;;;2878:39;;;::::0;::::1;2530:131:::0;1038:6:11;;-1:-1:-1;;;;;1038:6:11;666:10:1;1178:23:11;1170:68;;;;-1:-1:-1;;;1170:68:11;;;;;;;:::i;:::-;2609:2:10::1;2612:1;2609:5;;;;;;;;:::i;:::-;;;;;;;2604:2;;:10;;;;;-1:-1:-1::0;;;;;2604:10:10::1;;;;;-1:-1:-1::0;;;;;2604:10:10::1;;;;;;2629:2;2632:1;2629:5;;;;;;;;:::i;:::-;;;;;;;2624:2;;:10;;;;;-1:-1:-1::0;;;;;2624:10:10::1;;;;;-1:-1:-1::0;;;;;2624:10:10::1;;;;;;2649:2;2652:1;2649:5;;;;;;;;:::i;:::-;;;;;;;2644:2;;:10;;;;;-1:-1:-1::0;;;;;2644:10:10::1;;;;;-1:-1:-1::0;;;;;2644:10:10::1;;;;;;2530:131:::0;:::o;13214:189:4:-;13324:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;13324:29:4;-1:-1:-1;;;;;13324:29:4;;;;;;;;;13368:28;;13324:24;;13368:28;;;;;;;13214:189;;;:::o;8548:102::-;8616:27;8626:2;8630:8;8616:27;;;;;;;;;;;;:9;:27::i;11145:1958::-;11255:35;11293:20;11305:7;11293:11;:20::i;:::-;11366:18;;11255:58;;-1:-1:-1;11324:22:4;;-1:-1:-1;;;;;11350:34:4;666:10:1;-1:-1:-1;;;;;11350:34:4;;:86;;;-1:-1:-1;666:10:1;11400:20:4;11412:7;11400:11;:20::i;:::-;-1:-1:-1;;;;;11400:36:4;;11350:86;:152;;;-1:-1:-1;11469:18:4;;11452:50;;666:10:1;7160:162:4;:::i;11452:50::-;11324:179;;11522:17;11514:80;;;;-1:-1:-1;;;11514:80:4;;15087:2:14;11514:80:4;;;15069:21:14;15126:2;15106:18;;;15099:30;15165:34;15145:18;;;15138:62;-1:-1:-1;;;15216:18:14;;;15209:48;15274:19;;11514:80:4;14885:414:14;11514:80:4;11635:4;-1:-1:-1;;;;;11613:26:4;:13;:18;;;-1:-1:-1;;;;;11613:26:4;;11605:77;;;;-1:-1:-1;;;11605:77:4;;15506:2:14;11605:77:4;;;15488:21:14;15545:2;15525:18;;;15518:30;15584:34;15564:18;;;15557:62;-1:-1:-1;;;15635:18:14;;;15628:36;15681:19;;11605:77:4;15304:402:14;11605:77:4;-1:-1:-1;;;;;11700:16:4;;11692:66;;;;-1:-1:-1;;;11692:66:4;;15913:2:14;11692:66:4;;;15895:21:14;15952:2;15932:18;;;15925:30;15991:34;15971:18;;;15964:62;-1:-1:-1;;;16042:18:14;;;16035:35;16087:19;;11692:66:4;15711:401:14;11692:66:4;11874:49;11891:1;11895:7;11904:13;:18;;;11874:8;:49::i;:::-;-1:-1:-1;;;;;12213:18:4;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;;;;;12213:31:4;;;-1:-1:-1;;;;;12213:31:4;;;-1:-1:-1;;12213:31:4;;;;;;;12258:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;12258:29:4;;;;;;;;;;;;;12302:20;;;:11;:20;;;;;;:30;;-1:-1:-1;;;;;;12346:61:4;;;;-1:-1:-1;;;12391:15:4;12346:61;;;;;;12677:11;;;12706:24;;;;;:29;12677:11;;12706:29;12702:290;;12773:20;12781:11;8490:4;8523:12;-1:-1:-1;8513:22:4;8433:109;12773:20;12769:209;;;12849:18;;;12817:24;;;:11;:24;;;;;;;;:50;;12931:28;;;;12889:70;;-1:-1:-1;;;12889:70:4;-1:-1:-1;;;;;;12889:70:4;;;-1:-1:-1;;;;;12817:50:4;;;12889:70;;;;;;;12769:209;12189:813;13036:7;13032:2;-1:-1:-1;;;;;13017:27:4;13026:4;-1:-1:-1;;;;;13017:27:4;;;;;;;;;;;13054:42;11245:1858;;11145:1958;;;:::o;4255:524::-;-1:-1:-1;;;;;;;;;;;;;;;;;4357:16:4;4365:7;8490:4;8523:12;-1:-1:-1;8513:22:4;8433:109;4357:16;4349:71;;;;-1:-1:-1;;;4349:71:4;;16319:2:14;4349:71:4;;;16301:21:14;16358:2;16338:18;;;16331:30;16397:34;16377:18;;;16370:62;-1:-1:-1;;;16448:18:14;;;16441:40;16498:19;;4349:71:4;16117:406:14;4349:71:4;4475:7;4455:240;4521:31;4555:17;;;:11;:17;;;;;;;;;4521:51;;;;;;;;;-1:-1:-1;;;;;4521:51:4;;;;;-1:-1:-1;;;4521:51:4;;;;;;;;;;;;4594:28;4590:91;;4653:9;4255:524;-1:-1:-1;;;4255:524:4:o;4590:91::-;-1:-1:-1;;;4495:6:4;4455:240;;2034:169:11;2108:6;;;-1:-1:-1;;;;;2124:17:11;;;-1:-1:-1;;;;;;2124:17:11;;;;;;;2156:40;;2108:6;;;2124:17;2108:6;;2156:40;;2089:16;;2156:40;2079:124;2034:169;:::o;13956:783:4:-;14106:4;-1:-1:-1;;;;;14126:13:4;;1034:20:0;1080:8;14122:611:4;;14161:72;;-1:-1:-1;;;14161:72:4;;-1:-1:-1;;;;;14161:36:4;;;;;:72;;666:10:1;;14212:4:4;;14218:7;;14227:5;;14161:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14161:72:4;;;;;;;;-1:-1:-1;;14161:72:4;;;;;;;;;;;;:::i;:::-;;;14157:524;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14404:13:4;;14400:267;;14446:61;;-1:-1:-1;;;14446:61:4;;;;;;;:::i;14400:267::-;14619:6;14613:13;14604:6;14600:2;14596:15;14589:38;14157:524;-1:-1:-1;;;;;;14283:55:4;-1:-1:-1;;;14283:55:4;;-1:-1:-1;14276:62:4;;14122:611;-1:-1:-1;14718:4:4;14122:611;13956:783;;;;;;:::o;1507:112:10:-;1567:13;1599;1592:20;;;;;:::i;275:703:13:-;331:13;548:10;544:51;;-1:-1:-1;;574:10:13;;;;;;;;;;;;-1:-1:-1;;;574:10:13;;;;;275:703::o;544:51::-;619:5;604:12;658:75;665:9;;658:75;;690:8;;;;:::i;:::-;;-1:-1:-1;712:10:13;;-1:-1:-1;720:2:13;712:10;;:::i;:::-;;;658:75;;;742:19;774:6;764:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;764:17:13;;742:39;;791:150;798:10;;791:150;;824:11;834:1;824:11;;:::i;:::-;;-1:-1:-1;892:10:13;900:2;892:5;:10;:::i;:::-;879:24;;:2;:24;:::i;:::-;866:39;;849:6;856;849:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;849:56:13;;;;;;;;-1:-1:-1;919:11:13;928:2;919:11;;:::i;:::-;;;791:150;;9001:157:4;9119:32;9125:2;9129:8;9139:5;9146:4;9538:20;9561:12;-1:-1:-1;;;;;9591:16:4;;9583:62;;;;-1:-1:-1;;;9583:62:4;;18141:2:14;9583:62:4;;;18123:21:14;18180:2;18160:18;;;18153:30;18219:34;18199:18;;;18192:62;-1:-1:-1;;;18270:18:14;;;18263:31;18311:19;;9583:62:4;17939:397:14;9583:62:4;9663:13;9655:66;;;;-1:-1:-1;;;9655:66:4;;18543:2:14;9655:66:4;;;18525:21:14;18582:2;18562:18;;;18555:30;18621:34;18601:18;;;18594:62;-1:-1:-1;;;18672:18:14;;;18665:38;18720:19;;9655:66:4;18341:404:14;9655:66:4;-1:-1:-1;;;;;10065:16:4;;;;;;:12;:16;;;;;;;;:45;;-1:-1:-1;;;;;;;;;10065:45:4;;-1:-1:-1;;;;;10065:45:4;;;;;;;;;;10124:50;;;;;;;;;;;;;;10189:25;;;:11;:25;;;;;:35;;-1:-1:-1;;;;;;10238:66:4;;;;-1:-1:-1;;;10288:15:4;10238:66;;;;;;;10189:25;;10369:405;10389:8;10385:1;:12;10369:405;;;10427:38;;10452:12;;-1:-1:-1;;;;;10427:38:4;;;10444:1;;10427:38;;10444:1;;10427:38;10487:4;10483:244;;;10548:59;10579:1;10583:2;10587:12;10601:5;10548:22;:59::i;:::-;10515:193;;;;-1:-1:-1;;;10515:193:4;;;;;;;:::i;:::-;10745:14;;;;;10399:3;10369:405;;;-1:-1:-1;10788:12:4;:27;10836:60;7843:344;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:131:14;-1:-1:-1;;;;;;88:32:14;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:173::-;660:20;;-1:-1:-1;;;;;709:31:14;;699:42;;689:70;;755:1;752;745:12;689:70;592:173;;;:::o;770:186::-;829:6;882:2;870:9;861:7;857:23;853:32;850:52;;;898:1;895;888:12;850:52;921:29;940:9;921:29;:::i;961:632::-;1132:2;1184:21;;;1254:13;;1157:18;;;1276:22;;;1103:4;;1132:2;1355:15;;;;1329:2;1314:18;;;1103:4;1398:169;1412:6;1409:1;1406:13;1398:169;;;1473:13;;1461:26;;1542:15;;;;1507:12;;;;1434:1;1427:9;1398:169;;;-1:-1:-1;1584:3:14;;961:632;-1:-1:-1;;;;;;961:632:14:o;1598:258::-;1670:1;1680:113;1694:6;1691:1;1688:13;1680:113;;;1770:11;;;1764:18;1751:11;;;1744:39;1716:2;1709:10;1680:113;;;1811:6;1808:1;1805:13;1802:48;;;-1:-1:-1;;1846:1:14;1828:16;;1821:27;1598:258::o;1861:::-;1903:3;1941:5;1935:12;1968:6;1963:3;1956:19;1984:63;2040:6;2033:4;2028:3;2024:14;2017:4;2010:5;2006:16;1984:63;:::i;:::-;2101:2;2080:15;-1:-1:-1;;2076:29:14;2067:39;;;;2108:4;2063:50;;1861:258;-1:-1:-1;;1861:258:14:o;2124:220::-;2273:2;2262:9;2255:21;2236:4;2293:45;2334:2;2323:9;2319:18;2311:6;2293:45;:::i;2349:180::-;2408:6;2461:2;2449:9;2440:7;2436:23;2432:32;2429:52;;;2477:1;2474;2467:12;2429:52;-1:-1:-1;2500:23:14;;2349:180;-1:-1:-1;2349:180:14:o;2742:254::-;2810:6;2818;2871:2;2859:9;2850:7;2846:23;2842:32;2839:52;;;2887:1;2884;2877:12;2839:52;2910:29;2929:9;2910:29;:::i;:::-;2900:39;2986:2;2971:18;;;;2958:32;;-1:-1:-1;;;2742:254:14:o;3183:328::-;3260:6;3268;3276;3329:2;3317:9;3308:7;3304:23;3300:32;3297:52;;;3345:1;3342;3335:12;3297:52;3368:29;3387:9;3368:29;:::i;:::-;3358:39;;3416:38;3450:2;3439:9;3435:18;3416:38;:::i;:::-;3406:48;;3501:2;3490:9;3486:18;3473:32;3463:42;;3183:328;;;;;:::o;3516:347::-;3581:6;3589;3642:2;3630:9;3621:7;3617:23;3613:32;3610:52;;;3658:1;3655;3648:12;3610:52;3681:29;3700:9;3681:29;:::i;:::-;3671:39;;3760:2;3749:9;3745:18;3732:32;3807:5;3800:13;3793:21;3786:5;3783:32;3773:60;;3829:1;3826;3819:12;3773:60;3852:5;3842:15;;;3516:347;;;;;:::o;3868:127::-;3929:10;3924:3;3920:20;3917:1;3910:31;3960:4;3957:1;3950:15;3984:4;3981:1;3974:15;4000:275;4071:2;4065:9;4136:2;4117:13;;-1:-1:-1;;4113:27:14;4101:40;;4171:18;4156:34;;4192:22;;;4153:62;4150:88;;;4218:18;;:::i;:::-;4254:2;4247:22;4000:275;;-1:-1:-1;4000:275:14:o;4280:406::-;4344:5;4378:18;4370:6;4367:30;4364:56;;;4400:18;;:::i;:::-;4438:57;4483:2;4462:15;;-1:-1:-1;;4458:29:14;4489:4;4454:40;4438:57;:::i;:::-;4429:66;;4518:6;4511:5;4504:21;4558:3;4549:6;4544:3;4540:16;4537:25;4534:45;;;4575:1;4572;4565:12;4534:45;4624:6;4619:3;4612:4;4605:5;4601:16;4588:43;4678:1;4671:4;4662:6;4655:5;4651:18;4647:29;4640:40;4280:406;;;;;:::o;4691:666::-;4786:6;4794;4802;4810;4863:3;4851:9;4842:7;4838:23;4834:33;4831:53;;;4880:1;4877;4870:12;4831:53;4903:29;4922:9;4903:29;:::i;:::-;4893:39;;4951:38;4985:2;4974:9;4970:18;4951:38;:::i;:::-;4941:48;;5036:2;5025:9;5021:18;5008:32;4998:42;;5091:2;5080:9;5076:18;5063:32;5118:18;5110:6;5107:30;5104:50;;;5150:1;5147;5140:12;5104:50;5173:22;;5226:4;5218:13;;5214:27;-1:-1:-1;5204:55:14;;5255:1;5252;5245:12;5204:55;5278:73;5343:7;5338:2;5325:16;5320:2;5316;5312:11;5278:73;:::i;:::-;5268:83;;;4691:666;;;;;;;:::o;5362:450::-;5431:6;5484:2;5472:9;5463:7;5459:23;5455:32;5452:52;;;5500:1;5497;5490:12;5452:52;5540:9;5527:23;5573:18;5565:6;5562:30;5559:50;;;5605:1;5602;5595:12;5559:50;5628:22;;5681:4;5673:13;;5669:27;-1:-1:-1;5659:55:14;;5710:1;5707;5700:12;5659:55;5733:73;5798:7;5793:2;5780:16;5775:2;5771;5767:11;5733:73;:::i;5817:260::-;5885:6;5893;5946:2;5934:9;5925:7;5921:23;5917:32;5914:52;;;5962:1;5959;5952:12;5914:52;5985:29;6004:9;5985:29;:::i;:::-;5975:39;;6033:38;6067:2;6056:9;6052:18;6033:38;:::i;:::-;6023:48;;5817:260;;;;;:::o;6082:952::-;6166:6;6197:2;6240;6228:9;6219:7;6215:23;6211:32;6208:52;;;6256:1;6253;6246:12;6208:52;6296:9;6283:23;6325:18;6366:2;6358:6;6355:14;6352:34;;;6382:1;6379;6372:12;6352:34;6420:6;6409:9;6405:22;6395:32;;6465:7;6458:4;6454:2;6450:13;6446:27;6436:55;;6487:1;6484;6477:12;6436:55;6523:2;6510:16;6545:2;6541;6538:10;6535:36;;;6551:18;;:::i;:::-;6597:2;6594:1;6590:10;6580:20;;6620:28;6644:2;6640;6636:11;6620:28;:::i;:::-;6682:15;;;6752:11;;;6748:20;;;6713:12;;;;6780:19;;;6777:39;;;6812:1;6809;6802:12;6777:39;6836:11;;;;6856:148;6872:6;6867:3;6864:15;6856:148;;;6938:23;6957:3;6938:23;:::i;:::-;6926:36;;6889:12;;;;6982;;;;6856:148;;;7023:5;6082:952;-1:-1:-1;;;;;;;;6082:952:14:o;7039:127::-;7100:10;7095:3;7091:20;7088:1;7081:31;7131:4;7128:1;7121:15;7155:4;7152:1;7145:15;7171:127;7232:10;7227:3;7223:20;7220:1;7213:31;7263:4;7260:1;7253:15;7287:4;7284:1;7277:15;7303:135;7342:3;-1:-1:-1;;7363:17:14;;7360:43;;;7383:18;;:::i;:::-;-1:-1:-1;7430:1:14;7419:13;;7303:135::o;7443:380::-;7522:1;7518:12;;;;7565;;;7586:61;;7640:4;7632:6;7628:17;7618:27;;7586:61;7693:2;7685:6;7682:14;7662:18;7659:38;7656:161;;;7739:10;7734:3;7730:20;7727:1;7720:31;7774:4;7771:1;7764:15;7802:4;7799:1;7792:15;7656:161;;7443:380;;;:::o;9484:128::-;9524:3;9555:1;9551:6;9548:1;9545:13;9542:39;;;9561:18;;:::i;:::-;-1:-1:-1;9597:9:14;;9484:128::o;11205:356::-;11407:2;11389:21;;;11426:18;;;11419:30;11485:34;11480:2;11465:18;;11458:62;11552:2;11537:18;;11205:356::o;12737:415::-;12939:2;12921:21;;;12978:2;12958:18;;;12951:30;13017:34;13012:2;12997:18;;12990:62;-1:-1:-1;;;13083:2:14;13068:18;;13061:49;13142:3;13127:19;;12737:415::o;13573:470::-;13752:3;13790:6;13784:13;13806:53;13852:6;13847:3;13840:4;13832:6;13828:17;13806:53;:::i;:::-;13922:13;;13881:16;;;;13944:57;13922:13;13881:16;13978:4;13966:17;;13944:57;:::i;:::-;14017:20;;13573:470;-1:-1:-1;;;;13573:470:14:o;14455:127::-;14516:10;14511:3;14507:20;14504:1;14497:31;14547:4;14544:1;14537:15;14571:4;14568:1;14561:15;14587:120;14627:1;14653;14643:35;;14658:18;;:::i;:::-;-1:-1:-1;14692:9:14;;14587:120::o;14712:168::-;14752:7;14818:1;14814;14810:6;14806:14;14803:1;14800:21;14795:1;14788:9;14781:17;14777:45;14774:71;;;14825:18;;:::i;:::-;-1:-1:-1;14865:9:14;;14712:168::o;16944:489::-;-1:-1:-1;;;;;17213:15:14;;;17195:34;;17265:15;;17260:2;17245:18;;17238:43;17312:2;17297:18;;17290:34;;;17360:3;17355:2;17340:18;;17333:31;;;17138:4;;17381:46;;17407:19;;17399:6;17381:46;:::i;:::-;17373:54;16944:489;-1:-1:-1;;;;;;16944:489:14:o;17438:249::-;17507:6;17560:2;17548:9;17539:7;17535:23;17531:32;17528:52;;;17576:1;17573;17566:12;17528:52;17608:9;17602:16;17627:30;17651:5;17627:30;:::i;17692:125::-;17732:4;17760:1;17757;17754:8;17751:34;;;17765:18;;:::i;:::-;-1:-1:-1;17802:9:14;;17692:125::o;17822:112::-;17854:1;17880;17870:35;;17885:18;;:::i;:::-;-1:-1:-1;17919:9:14;;17822:112::o

ipfs://c69c0bccbf5679c36f0ef3d570ad360057705a1cc4cc34b1883231c778747cc1