Token Skullys... Join the cult.

/**
 *Submitted for verification at Etherscan.io on 2021-10-06
*/

// Sources flattened with hardhat v2.6.4 https://hardhat.org

// File @openzeppelin/contracts/utils/[email protected]

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.7;

/**
   ▄████████    ▄█   ▄█▄ ███    █▄   ▄█        ▄█       ▄██   ▄      ▄████████
  ███    ███   ███ ▄███▀ ███    ███ ███       ███       ███   ██▄   ███    ███
  ███    █▀    ███▐██▀   ███    ███ ███       ███       ███▄▄▄███   ███    █▀
  ███         ▄█████▀    ███    ███ ███       ███       ▀▀▀▀▀▀███   ███
▀███████████ ▀▀█████▄    ███    ███ ███       ███       ▄██   ███ ▀███████████
         ███   ███▐██▄   ███    ███ ███       ███       ███   ███          ███
   ▄█    ███   ███ ▀███▄ ███    ███ ███▌    ▄ ███▌    ▄ ███   ███    ▄█    ███
 ▄████████▀    ███   ▀█▀ ████████▀  █████▄▄██ █████▄▄██  ▀█████▀   ▄████████▀
**/

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}


// File @openzeppelin/contracts/utils/introspection/[email protected]





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


// File @openzeppelin/contracts/token/ERC721/[email protected]





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


// File @openzeppelin/contracts/token/ERC721/[email protected]





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


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]





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


// File @openzeppelin/contracts/utils/[email protected]





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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// File @openzeppelin/contracts/utils/[email protected]





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


// File @openzeppelin/contracts/utils/[email protected]





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


// File @openzeppelin/contracts/utils/introspection/[email protected]





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


// File @openzeppelin/contracts/token/ERC721/[email protected]











/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

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

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @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 ||
            super.supportsInterface(interfaceId);
    }

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

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

    /**
     * @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 virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @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.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @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`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);
    }

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

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * 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
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

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

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), 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.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]





/**
 * @dev ERC721 token with storage based token URI management.
 */
abstract contract ERC721URIStorage is ERC721 {
    using Strings for uint256;

    // Optional mapping for token URIs
    mapping(uint256 => string) private _tokenURIs;

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = _baseURI();

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(base, _tokenURI));
        }

        return super.tokenURI(tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

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

        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
        }
    }
}


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]





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


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]






/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

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

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, tokenId);

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}


// File @openzeppelin/contracts/utils/math/[email protected]





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

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

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

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

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

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

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

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

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

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

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

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

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

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


// File @openzeppelin/contracts/utils/introspection/[email protected]





/**
 * @dev Storage based implementation of the {IERC165} interface.
 *
 * Contracts may inherit from this and call {_registerInterface} to declare
 * their support of an interface.
 */
abstract contract ERC165Storage is ERC165 {
    /**
     * @dev Mapping of interface ids to whether or not it's supported.
     */
    mapping(bytes4 => bool) private _supportedInterfaces;

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return super.supportsInterface(interfaceId) || _supportedInterfaces[interfaceId];
    }

    /**
     * @dev Registers the contract as an implementer of the interface defined by
     * `interfaceId`. Support of the actual ERC165 interface is automatic and
     * registering its interface id is not required.
     *
     * See {IERC165-supportsInterface}.
     *
     * Requirements:
     *
     * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
     */
    function _registerInterface(bytes4 interfaceId) internal virtual {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}


// File @openzeppelin/contracts/interfaces/[email protected]






// File @openzeppelin/contracts/interfaces/[email protected]





/**
 * @dev Interface for the NFT Royalty Standard
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Called with the sale price to determine how much royalty is owed and to whom.
     * @param tokenId - the NFT asset queried for royalty information
     * @param salePrice - the sale price of the NFT asset specified by `tokenId`
     * @return receiver - address of who should be sent the royalty payment
     * @return royaltyAmount - the royalty payment amount for `salePrice`
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        returns (address receiver, uint256 royaltyAmount);
}


// File contracts/ERC2981.sol

/***
 *    ███████╗██████╗  ██████╗██████╗  █████╗  █████╗  ██╗
 *    ██╔════╝██╔══██╗██╔════╝╚════██╗██╔══██╗██╔══██╗███║
 *    █████╗  ██████╔╝██║      █████╔╝╚██████║╚█████╔╝╚██║
 *    ██╔══╝  ██╔══██╗██║     ██╔═══╝  ╚═══██║██╔══██╗ ██║
 *    ███████╗██║  ██║╚██████╗███████╗ █████╔╝╚█████╔╝ ██║
 *    ╚══════╝╚═╝  ╚═╝ ╚═════╝╚══════╝ ╚════╝  ╚════╝  ╚═╝
 * Written by MaxflowO2
 * You can follow along at https://github.com/MaxflowO2/ERC2981
 */







abstract contract ERC2981 is IERC2981, ERC165Storage {
  using SafeMath for uint256;

  // Bytes4 Code for EIP-2981
  bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;

  // Mappings _tokenID -> values
  address receiver;
  uint256 royaltyPercentage;

  constructor() {

    // Using ERC165Storage set EIP-2981
    _registerInterface(_INTERFACE_ID_ERC2981);

  }

  // Set to be internal function _setReceiver
  function _setReceiver(address _address) internal {
    receiver = _address;
  }

  // Set to be internal function _setRoyaltyPercentage
  function _setRoyaltyPercentage(uint256 _royaltyPercentage) internal {
    royaltyPercentage = _royaltyPercentage;
  }

  // Override for royaltyInfo(uint256, uint256)
  // uses SafeMath for uint256
  function royaltyInfo(uint256 _tokenId, uint256 _salePrice) external view override(IERC2981) returns (address Receiver, uint256 royaltyAmount) {
    Receiver = receiver;
    royaltyAmount = _salePrice.div(100).mul(royaltyPercentage);
  }
}


// File contracts/Skullys.sol




/**
   ▄████████    ▄█   ▄█▄ ███    █▄   ▄█        ▄█       ▄██   ▄      ▄████████
  ███    ███   ███ ▄███▀ ███    ███ ███       ███       ███   ██▄   ███    ███
  ███    █▀    ███▐██▀   ███    ███ ███       ███       ███▄▄▄███   ███    █▀
  ███         ▄█████▀    ███    ███ ███       ███       ▀▀▀▀▀▀███   ███
▀███████████ ▀▀█████▄    ███    ███ ███       ███       ▄██   ███ ▀███████████
         ███   ███▐██▄   ███    ███ ███       ███       ███   ███          ███
   ▄█    ███   ███ ▀███▄ ███    ███ ███▌    ▄ ███▌    ▄ ███   ███    ▄█    ███
 ▄████████▀    ███   ▀█▀ ████████▀  █████▄▄██ █████▄▄██  ▀█████▀   ▄████████▀
**/






contract Skullys is ERC721Enumerable, ERC2981 {

    using SafeMath for uint;
    using SafeMath for uint256;
    using Counters for Counters.Counter;

    enum Status {
        Closed,
        PresaleStart,
        PublicSaleStart
    }

    Counters.Counter private _tokenIds;

    string public PROVENANCE = "";
    string private _baseURIextended = "";

    uint constant public MAX_SKULLYS = 1000;
    uint constant public SKULLYS_PRICE = 150 ether;
    uint constant public MAX_SKULLYS_PER_OWNER = 5;

    uint public presaleStartTime = 2547586402; // default to some time far in the future
    uint public publicSaleStartTime = presaleStartTime + 24 hours; // starts 24 hours after the presale

    mapping(address => uint) public freeSkullysPerOwner;
    mapping(address => uint) public skullysMintedByOwner;

    mapping(address => bool) private isTeam;
    mapping(address => bool) public isOnWhiteList;

    // Team Addresses
    address[] private _team = [
        0xC87bf1972Dd048404CBd3FbA300b69277552C472, // 65 - Art, generative art, social media
        0x14E8F54f35eE42Cdf436A19086659B34dA6D9D47  // 25 - Dev
    ];

    // team address payout shares
    uint256[] private _team_shares = [65, 25];  // 65 and 25 for team, and then 2*5 for specials

    // payout shares for holders of special tokenIds
    uint256[] private _specials        = [6, 66, 69, 420, 666];
    uint256[] private _specials_shares = [2,  2,  2,   2,   2];

    // For EIP-2981
    uint256 constant private ROYALTIES_PERCENTAGE = 10;

    constructor()
        ERC721("Skullys... Join the cult.", "SKULLY")
    {
        isTeam[msg.sender] = true;
        isTeam[0xC87bf1972Dd048404CBd3FbA300b69277552C472] = true;
        isTeam[0x14E8F54f35eE42Cdf436A19086659B34dA6D9D47] = true;

        _setReceiver(address(this));
        _setRoyaltyPercentage(ROYALTIES_PERCENTAGE);
    }

    modifier onlyTeam() {
        require(isTeam[msg.sender], "Can't do that, you are not part of the team");
        _;
    }

    modifier verifyFreeMint(address _to) {
        require(isOnWhiteList[_to] || isTeam[msg.sender], "Must be on the whitelist to mint for free");
        require(freeSkullysPerOwner[_to] == 0, "Can't mint more than one for free");
        require(getStatus() == Status.PresaleStart || getStatus() == Status.PublicSaleStart || isTeam[msg.sender], "Minting has not started");
        require(totalSupply() < MAX_SKULLYS, "Sold out");
        require(skullysMintedByOwner[msg.sender] < MAX_SKULLYS_PER_OWNER, "Can't mint more than 5 Skullys");
        _;
    }

    modifier verifyMint(address _to) {
        require(getStatus() == Status.PublicSaleStart, "Public sale has not started");
        require(SKULLYS_PRICE <= msg.value, "Didn't send enough payment");
        require(totalSupply() < MAX_SKULLYS, "Sold out");
        require(totalSupply().add(1) <= MAX_SKULLYS, "Purchase would exceed max supply");
        require(skullysMintedByOwner[msg.sender] < MAX_SKULLYS_PER_OWNER, "Can't mint more than 5 Skullys");
        _;
    }

    function setProvenanceHash(string memory _provenanceHash) external onlyTeam {
        PROVENANCE = _provenanceHash;
    }

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

    function setBaseURI(string memory baseURI_) external onlyTeam {
        _baseURIextended = baseURI_;
    }

    function setManyWhiteList(address[] memory _addr) external onlyTeam {
        for(uint i = 0; i < _addr.length; i++){
            isOnWhiteList[_addr[i]] = true;
        }
    }

    function getStatus() public view returns (Status) {
        if(block.timestamp >= publicSaleStartTime) {
            return Status.PublicSaleStart;
        } else if (block.timestamp >= presaleStartTime) {
            return Status.PresaleStart;
        }
        return Status.Closed;
    }

    function setPreSaleTime(uint _newTime) public onlyTeam {
        presaleStartTime = _newTime;
        publicSaleStartTime = _newTime + 9 hours;
    }

    function mintFreeSkully() external verifyFreeMint(msg.sender) {
        address _to = msg.sender;

        _tokenIds.increment();
        uint mintId = _tokenIds.current();

        _safeMint(_to, mintId);
        skullysMintedByOwner[_to]++;
        freeSkullysPerOwner[_to]++;
        emit SkullyMinted(mintId, _to);
    }

    function mintSkully() external payable verifyMint(msg.sender) {
        address _to = msg.sender;

        _tokenIds.increment();
        uint mintId = _tokenIds.current();

        _safeMint(_to, mintId);
        skullysMintedByOwner[_to]++;
        payable(_team[0]).transfer(msg.value.sub(msg.value.div(40)));  // team member 0 gets 97.5% of mint revenue
        payable(_team[1]).transfer(msg.value.div(40));  // team member 1 gets 2.5% of mint revenue
        emit SkullyMinted(mintId, _to);
    }

    function totalSupply() public view override(ERC721Enumerable) returns (uint256) {
        return super.totalSupply();
    }


    function _getTotalPaymentShares() internal view returns (uint256) {
        uint256 totalShares = 0;
        for (uint i = 0; i < _team.length; i++) {
            totalShares += _team_shares[i];
        }
        for (uint i = 0; i < _specials.length; i++) {
            totalShares += _specials_shares[i];
        }
        return totalShares;
    }

    function withdrawAll() public onlyTeam {
        require(address(this).balance > 0, "Cannot withdraw, balance is empty");

        uint256 totalShares = _getTotalPaymentShares();

        uint256 totalReceived = address(this).balance;

        for (uint i = 0; i < _team.length; i++) {
            address payable wallet = payable(_team[i]);
            uint256 payment = (totalReceived * _team_shares[i]) / totalShares;
            Address.sendValue(wallet, payment);
        }
        for (uint i = 0; i < _specials.length; i++) {
            address payable wallet;
            if (totalSupply() < _specials[i]) {
                // if this special tokenId hasn't been minted yet, send payment shares to artist
                wallet = payable(_team[0]);
            } else {
                // payout holder of this special tokenId
                wallet = payable(ownerOf(_specials[i]));
            }
            uint256 payment = (totalReceived * _specials_shares[i]) / totalShares;
            Address.sendValue(wallet, payment);
        }
    }

    // ensure this contract can receive payments (royalties)
    receive () external payable {}

    event SkullyMinted(uint _id, address _address);
}
/**

 Art:       @yolofinancial
 Code:      @CodeLarkin    :  codelarkin.eth
 Community: @farmgoddao

   ██╗      █████╗ ██████╗ ██╗  ██╗██╗███╗   ██╗
   ██║     ██╔══██╗██╔══██╗██║ ██╔╝██║████╗  ██║
   ██║     ███████║██████╔╝█████╔╝ ██║██╔██╗ ██║
   ██║     ██╔══██║██╔══██╗██╔═██╗ ██║██║╚██╗██║
   ███████╗██║  ██║██║  ██║██║  ██╗██║██║ ╚████║
   ╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝╚═╝  ╚═══╝

**/

• 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":false,"internalType":"uint256","name":"_id","type":"uint256"},{"indexed":false,"internalType":"address","name":"_address","type":"address"}],"name":"SkullyMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MAX_SKULLYS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SKULLYS_PER_OWNER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PROVENANCE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SKULLYS_PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"address","name":"","type":"address"}],"name":"freeSkullysPerOwner","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":[],"name":"getStatus","outputs":[{"internalType":"enum Skullys.Status","name":"","type":"uint8"}],"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":[{"internalType":"address","name":"","type":"address"}],"name":"isOnWhiteList","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintFreeSkully","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"mintSkully","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"presaleStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicSaleStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"Receiver","type":"address"},{"internalType":"uint256","name":"royaltyAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI_","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_addr","type":"address[]"}],"name":"setManyWhiteList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newTime","type":"uint256"}],"name":"setPreSaleTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_provenanceHash","type":"string"}],"name":"setProvenanceHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"skullysMintedByOwner","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":[],"name":"withdrawAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

60a06040819052600060808190526200001b91600e9162000314565b506040805160208101918290526000908190526200003c91600f9162000314565b506397d91562601081905562000056906201518062000499565b6011556040805180820190915273c87bf1972dd048404cbd3fba300b69277552c47281527314e8f54f35ee42cdf436a19086659b34da6d9d476020820152620000a4906016906002620003a3565b50604080518082019091526041815260196020820152620000ca906017906002620003fb565b506040805160a08101825260068152604260208201526045918101919091526101a4606082015261029a6080820152620001099060189060056200043e565b506040805160a08101825260028082526020820181905291810182905260608101829052608081019190915262000145906019906005620003fb565b503480156200015357600080fd5b50604080518082018252601981527f536b756c6c79732e2e2e204a6f696e207468652063756c742e00000000000000602080830191825283518085019094526006845265534b554c4c5960d01b908401528151919291620001b79160009162000314565b508051620001cd90600190602084019062000314565b50620001e4915063152a902d60e11b905062000290565b336000908152601460205260408120805460ff1990811660019081179092557f6e3aebbd532301c8852d7ba018d884a5724dd3d34d67350d0b817a283b4a53dc80548216831790557314e8f54f35ee42cdf436a19086659b34da6d9d479092527f1237210962a6a0315a4a89967d39620bd4d349d07fcb388fd1fd6385a96fff188054909216179055600b80546001600160a01b031916301790556200028a600a600c55565b620004fd565b6001600160e01b03198082161415620002ef5760405162461bcd60e51b815260206004820152601c60248201527f4552433136353a20696e76616c696420696e7465726661636520696400000000604482015260640160405180910390fd5b6001600160e01b0319166000908152600a60205260409020805460ff19166001179055565b8280546200032290620004c0565b90600052602060002090601f01602090048101928262000346576000855562000391565b82601f106200036157805160ff191683800117855562000391565b8280016001018555821562000391579182015b828111156200039157825182559160200191906001019062000374565b506200039f92915062000482565b5090565b82805482825590600052602060002090810192821562000391579160200282015b828111156200039157825182546001600160a01b0319166001600160a01b03909116178255602090920191600190910190620003c4565b82805482825590600052602060002090810192821562000391579160200282015b8281111562000391578251829060ff169055916020019190600101906200041c565b82805482825590600052602060002090810192821562000391579160200282015b8281111562000391578251829061ffff169055916020019190600101906200045f565b5b808211156200039f576000815560010162000483565b60008219821115620004bb57634e487b7160e01b600052601160045260246000fd5b500190565b600181811c90821680620004d557607f821691505b60208210811415620004f757634e487b7160e01b600052602260045260246000fd5b50919050565b61324d806200050d6000396000f3fe60806040526004361061021d5760003560e01c806351bb5cc11161011d57806395d89b41116100b0578063c87b56dd1161007f578063e985e9c511610064578063e985e9c514610613578063ecb223ab1461065c578063efbf85a91461068c57600080fd5b8063c87b56dd146105c6578063cf239d47146105e657600080fd5b806395d89b411461055b578063a22cb46514610570578063a82524b214610590578063b88d4fde146105a657600080fd5b80636bb7b1d9116100ec5780636bb7b1d9146104fa57806370a0823114610510578063722633ba14610530578063853828b61461054657600080fd5b806351bb5cc11461049d57806355f804b3146104a55780636352211e146104c55780636373a6b1146104e557600080fd5b806323b872dd116101b05780632f745c591161017f57806342842e0e1161016457806342842e0e1461043b5780634e69d5601461045b5780634f6ccce71461047d57600080fd5b80632f745c5914610406578063348ec9e01461042657600080fd5b806323b872dd1461035a578063271222951461037a5780632a55205a146103a75780632c22642c146103e657600080fd5b8063095ea7b3116101ec578063095ea7b3146102e35780630f0e4f7314610305578063109695231461032557806318160ddd1461034557600080fd5b806301ffc9a714610229578063039577a31461025e57806306fdde0314610289578063081812fc146102ab57600080fd5b3661022457005b600080fd5b34801561023557600080fd5b50610249610244366004612d6f565b6106a1565b60405190151581526020015b60405180910390f35b34801561026a57600080fd5b5061027b680821ab0d441498000081565b604051908152602001610255565b34801561029557600080fd5b5061029e6106ee565b6040516102559190612f23565b3480156102b757600080fd5b506102cb6102c6366004612df2565b610780565b6040516001600160a01b039091168152602001610255565b3480156102ef57600080fd5b506103036102fe366004612c91565b61082b565b005b34801561031157600080fd5b50610303610320366004612df2565b61095d565b34801561033157600080fd5b50610303610340366004612da9565b6109f9565b34801561035157600080fd5b5061027b610a95565b34801561036657600080fd5b50610303610375366004612b9d565b610aa5565b34801561038657600080fd5b5061027b610395366004612b58565b60126020526000908152604090205481565b3480156103b357600080fd5b506103c76103c2366004612e0b565b610b2c565b604080516001600160a01b039093168352602083019190915201610255565b3480156103f257600080fd5b50610303610401366004612cbb565b610b5f565b34801561041257600080fd5b5061027b610421366004612c91565b610c6a565b34801561043257600080fd5b5061027b600581565b34801561044757600080fd5b50610303610456366004612b9d565b610d12565b34801561046757600080fd5b50610470610d2d565b6040516102559190612ee2565b34801561048957600080fd5b5061027b610498366004612df2565b610d53565b610303610df7565b3480156104b157600080fd5b506103036104c0366004612da9565b611134565b3480156104d157600080fd5b506102cb6104e0366004612df2565b6111cc565b3480156104f157600080fd5b5061029e611257565b34801561050657600080fd5b5061027b60115481565b34801561051c57600080fd5b5061027b61052b366004612b58565b6112e5565b34801561053c57600080fd5b5061027b6103e881565b34801561055257600080fd5b5061030361137f565b34801561056757600080fd5b5061029e611604565b34801561057c57600080fd5b5061030361058b366004612c55565b611613565b34801561059c57600080fd5b5061027b60105481565b3480156105b257600080fd5b506103036105c1366004612bd9565b6116f6565b3480156105d257600080fd5b5061029e6105e1366004612df2565b611784565b3480156105f257600080fd5b5061027b610601366004612b58565b60136020526000908152604090205481565b34801561061f57600080fd5b5061024961062e366004612b73565b6001600160a01b03918216600090815260056020908152604080832093909416825291909152205460ff1690565b34801561066857600080fd5b50610249610677366004612b58565b60156020526000908152604090205460ff1681565b34801561069857600080fd5b5061030361186d565b60006106ac82611baa565b806106e857507fffffffff0000000000000000000000000000000000000000000000000000000082166000908152600a602052604090205460ff165b92915050565b6060600080546106fd90613031565b80601f016020809104026020016040519081016040528092919081815260200182805461072990613031565b80156107765780601f1061074b57610100808354040283529160200191610776565b820191906000526020600020905b81548152906001019060200180831161075957829003601f168201915b5050505050905090565b6000818152600260205260408120546001600160a01b031661080f5760405162461bcd60e51b815260206004820152602c60248201527f4552433732313a20617070726f76656420717565727920666f72206e6f6e657860448201527f697374656e7420746f6b656e000000000000000000000000000000000000000060648201526084015b60405180910390fd5b506000908152600460205260409020546001600160a01b031690565b6000610836826111cc565b9050806001600160a01b0316836001600160a01b031614156108c05760405162461bcd60e51b815260206004820152602160248201527f4552433732313a20617070726f76616c20746f2063757272656e74206f776e6560448201527f72000000000000000000000000000000000000000000000000000000000000006064820152608401610806565b336001600160a01b03821614806108dc57506108dc813361062e565b61094e5760405162461bcd60e51b815260206004820152603860248201527f4552433732313a20617070726f76652063616c6c6572206973206e6f74206f7760448201527f6e6572206e6f7220617070726f76656420666f7220616c6c00000000000000006064820152608401610806565b6109588383611c00565b505050565b3360009081526014602052604090205460ff166109e25760405162461bcd60e51b815260206004820152602b60248201527f43616e277420646f20746861742c20796f7520617265206e6f7420706172742060448201527f6f6620746865207465616d0000000000000000000000000000000000000000006064820152608401610806565b60108190556109f381617e90612f85565b60115550565b3360009081526014602052604090205460ff16610a7e5760405162461bcd60e51b815260206004820152602b60248201527f43616e277420646f20746861742c20796f7520617265206e6f7420706172742060448201527f6f6620746865207465616d0000000000000000000000000000000000000000006064820152608401610806565b8051610a9190600e906020840190612a2d565b5050565b6000610aa060085490565b905090565b610aaf3382611c86565b610b215760405162461bcd60e51b815260206004820152603160248201527f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f60448201527f776e6572206e6f7220617070726f7665640000000000000000000000000000006064820152608401610806565b610958838383611d8e565b600b54600c546001600160a01b0390911690600090610b5690610b50856064611f7e565b90611f8a565b90509250929050565b3360009081526014602052604090205460ff16610be45760405162461bcd60e51b815260206004820152602b60248201527f43616e277420646f20746861742c20796f7520617265206e6f7420706172742060448201527f6f6620746865207465616d0000000000000000000000000000000000000000006064820152608401610806565b60005b8151811015610a9157600160156000848481518110610c0857610c08613188565b6020908102919091018101516001600160a01b0316825281019190915260400160002080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001691151591909117905580610c628161307f565b915050610be7565b6000610c75836112e5565b8210610ce95760405162461bcd60e51b815260206004820152602b60248201527f455243373231456e756d657261626c653a206f776e657220696e646578206f7560448201527f74206f6620626f756e64730000000000000000000000000000000000000000006064820152608401610806565b506001600160a01b03919091166000908152600660209081526040808320938352929052205490565b610958838383604051806020016040528060008152506116f6565b60006011544210610d3e5750600290565b6010544210610d4d5750600190565b50600090565b6000610d5e60085490565b8210610dd25760405162461bcd60e51b815260206004820152602c60248201527f455243373231456e756d657261626c653a20676c6f62616c20696e646578206f60448201527f7574206f6620626f756e647300000000000000000000000000000000000000006064820152608401610806565b60088281548110610de557610de5613188565b90600052602060002001549050919050565b336002610e02610d2d565b6002811115610e1357610e1361312a565b14610e605760405162461bcd60e51b815260206004820152601b60248201527f5075626c69632073616c6520686173206e6f74207374617274656400000000006044820152606401610806565b34680821ab0d44149800001115610eb95760405162461bcd60e51b815260206004820152601a60248201527f4469646e27742073656e6420656e6f756768207061796d656e740000000000006044820152606401610806565b6103e8610ec4610a95565b10610f115760405162461bcd60e51b815260206004820152600860248201527f536f6c64206f75740000000000000000000000000000000000000000000000006044820152606401610806565b6103e8610f276001610f21610a95565b90611f96565b1115610f755760405162461bcd60e51b815260206004820181905260248201527f507572636861736520776f756c6420657863656564206d617820737570706c796044820152606401610806565b33600090815260136020526040902054600511610fd45760405162461bcd60e51b815260206004820152601e60248201527f43616e2774206d696e74206d6f7265207468616e203520536b756c6c797300006044820152606401610806565b33610fe3600d80546001019055565b6000610fee600d5490565b9050610ffa8282611fa2565b6001600160a01b038216600090815260136020526040812080549161101e8361307f565b9190505550601660008154811061103757611037613188565b6000918252602090912001546001600160a01b03166108fc61106461105d346028611f7e565b3490611fbc565b6040518115909202916000818181858888f1935050505015801561108c573d6000803e3d6000fd5b5060166001815481106110a1576110a1613188565b6000918252602090912001546001600160a01b03166108fc6110c4346028611f7e565b6040518115909202916000818181858888f193505050501580156110ec573d6000803e3d6000fd5b50604080518281526001600160a01b03841660208201527f715c92d3596a1df470e5bd57f91bfc0daf37434842af26dd571f8c5e32b057e991015b60405180910390a1505050565b3360009081526014602052604090205460ff166111b95760405162461bcd60e51b815260206004820152602b60248201527f43616e277420646f20746861742c20796f7520617265206e6f7420706172742060448201527f6f6620746865207465616d0000000000000000000000000000000000000000006064820152608401610806565b8051610a9190600f906020840190612a2d565b6000818152600260205260408120546001600160a01b0316806106e85760405162461bcd60e51b815260206004820152602960248201527f4552433732313a206f776e657220717565727920666f72206e6f6e657869737460448201527f656e7420746f6b656e00000000000000000000000000000000000000000000006064820152608401610806565b600e805461126490613031565b80601f016020809104026020016040519081016040528092919081815260200182805461129090613031565b80156112dd5780601f106112b2576101008083540402835291602001916112dd565b820191906000526020600020905b8154815290600101906020018083116112c057829003601f168201915b505050505081565b60006001600160a01b0382166113635760405162461bcd60e51b815260206004820152602a60248201527f4552433732313a2062616c616e636520717565727920666f7220746865207a6560448201527f726f2061646472657373000000000000000000000000000000000000000000006064820152608401610806565b506001600160a01b031660009081526003602052604090205490565b3360009081526014602052604090205460ff166114045760405162461bcd60e51b815260206004820152602b60248201527f43616e277420646f20746861742c20796f7520617265206e6f7420706172742060448201527f6f6620746865207465616d0000000000000000000000000000000000000000006064820152608401610806565b6000471161147a5760405162461bcd60e51b815260206004820152602160248201527f43616e6e6f742077697468647261772c2062616c616e636520697320656d707460448201527f79000000000000000000000000000000000000000000000000000000000000006064820152608401610806565b6000611484611fc8565b90504760005b601654811015611518576000601682815481106114a9576114a9613188565b6000918252602082200154601780546001600160a01b0390921693508691859081106114d7576114d7613188565b9060005260206000200154856114ed9190612fb1565b6114f79190612f9d565b90506115038282612065565b505080806115109061307f565b91505061148a565b5060005b6018548110156109585760006018828154811061153b5761153b613188565b906000526020600020015461154e610a95565b101561158457601660008154811061156857611568613188565b6000918252602090912001546001600160a01b031690506115ad565b6115aa6018838154811061159a5761159a613188565b90600052602060002001546111cc565b90505b600084601984815481106115c3576115c3613188565b9060005260206000200154856115d99190612fb1565b6115e39190612f9d565b90506115ef8282612065565b505080806115fc9061307f565b91505061151c565b6060600180546106fd90613031565b6001600160a01b03821633141561166c5760405162461bcd60e51b815260206004820152601960248201527f4552433732313a20617070726f766520746f2063616c6c6572000000000000006044820152606401610806565b3360008181526005602090815260408083206001600160a01b0387168085529083529281902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b6117003383611c86565b6117725760405162461bcd60e51b815260206004820152603160248201527f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f60448201527f776e6572206e6f7220617070726f7665640000000000000000000000000000006064820152608401610806565b61177e8484848461217e565b50505050565b6000818152600260205260409020546060906001600160a01b03166118115760405162461bcd60e51b815260206004820152602f60248201527f4552433732314d657461646174613a2055524920717565727920666f72206e6f60448201527f6e6578697374656e7420746f6b656e00000000000000000000000000000000006064820152608401610806565b600061181b612207565b9050600081511161183b5760405180602001604052806000815250611866565b8061184584612216565b604051602001611856929190612e77565b6040516020818303038152906040525b9392505050565b3360008181526015602052604090205460ff168061189a57503360009081526014602052604090205460ff165b61190c5760405162461bcd60e51b815260206004820152602960248201527f4d757374206265206f6e207468652077686974656c69737420746f206d696e7460448201527f20666f72206672656500000000000000000000000000000000000000000000006064820152608401610806565b6001600160a01b038116600090815260126020526040902054156119985760405162461bcd60e51b815260206004820152602160248201527f43616e2774206d696e74206d6f7265207468616e206f6e6520666f722066726560448201527f65000000000000000000000000000000000000000000000000000000000000006064820152608401610806565b60016119a2610d2d565b60028111156119b3576119b361312a565b14806119d7575060026119c4610d2d565b60028111156119d5576119d561312a565b145b806119f157503360009081526014602052604090205460ff165b611a3d5760405162461bcd60e51b815260206004820152601760248201527f4d696e74696e6720686173206e6f7420737461727465640000000000000000006044820152606401610806565b6103e8611a48610a95565b10611a955760405162461bcd60e51b815260206004820152600860248201527f536f6c64206f75740000000000000000000000000000000000000000000000006044820152606401610806565b33600090815260136020526040902054600511611af45760405162461bcd60e51b815260206004820152601e60248201527f43616e2774206d696e74206d6f7265207468616e203520536b756c6c797300006044820152606401610806565b33611b03600d80546001019055565b6000611b0e600d5490565b9050611b1a8282611fa2565b6001600160a01b0382166000908152601360205260408120805491611b3e8361307f565b90915550506001600160a01b0382166000908152601260205260408120805491611b678361307f565b9091555050604080518281526001600160a01b03841660208201527f715c92d3596a1df470e5bd57f91bfc0daf37434842af26dd571f8c5e32b057e99101611127565b60007fffffffff0000000000000000000000000000000000000000000000000000000082167f780e9d630000000000000000000000000000000000000000000000000000000014806106e857506106e882612348565b600081815260046020526040902080547fffffffffffffffffffffffff0000000000000000000000000000000000000000166001600160a01b0384169081179091558190611c4d826111cc565b6001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b6000818152600260205260408120546001600160a01b0316611d105760405162461bcd60e51b815260206004820152602c60248201527f4552433732313a206f70657261746f7220717565727920666f72206e6f6e657860448201527f697374656e7420746f6b656e00000000000000000000000000000000000000006064820152608401610806565b6000611d1b836111cc565b9050806001600160a01b0316846001600160a01b03161480611d565750836001600160a01b0316611d4b84610780565b6001600160a01b0316145b80611d8657506001600160a01b0380821660009081526005602090815260408083209388168352929052205460ff165b949350505050565b826001600160a01b0316611da1826111cc565b6001600160a01b031614611e1d5760405162461bcd60e51b815260206004820152602960248201527f4552433732313a207472616e73666572206f6620746f6b656e2074686174206960448201527f73206e6f74206f776e00000000000000000000000000000000000000000000006064820152608401610806565b6001600160a01b038216611e985760405162461bcd60e51b8152602060048201526024808201527f4552433732313a207472616e7366657220746f20746865207a65726f2061646460448201527f72657373000000000000000000000000000000000000000000000000000000006064820152608401610806565b611ea383838361242b565b611eae600082611c00565b6001600160a01b0383166000908152600360205260408120805460019290611ed7908490612fee565b90915550506001600160a01b0382166000908152600360205260408120805460019290611f05908490612f85565b909155505060008181526002602052604080822080547fffffffffffffffffffffffff0000000000000000000000000000000000000000166001600160a01b0386811691821790925591518493918716917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91a4505050565b60006118668284612f9d565b60006118668284612fb1565b60006118668284612f85565b610a918282604051806020016040528060008152506124e3565b60006118668284612fee565b600080805b6016548110156120145760178181548110611fea57611fea613188565b9060005260206000200154826120009190612f85565b91508061200c8161307f565b915050611fcd565b5060005b60185481101561205f576019818154811061203557612035613188565b90600052602060002001548261204b9190612f85565b9150806120578161307f565b915050612018565b50919050565b804710156120b55760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a20696e73756666696369656e742062616c616e63650000006044820152606401610806565b6000826001600160a01b03168260405160006040518083038185875af1925050503d8060008114612102576040519150601f19603f3d011682016040523d82523d6000602084013e612107565b606091505b50509050806109585760405162461bcd60e51b815260206004820152603a60248201527f416464726573733a20756e61626c6520746f2073656e642076616c75652c207260448201527f6563697069656e74206d617920686176652072657665727465640000000000006064820152608401610806565b612189848484611d8e565b6121958484848461256c565b61177e5760405162461bcd60e51b815260206004820152603260248201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560448201527f63656976657220696d706c656d656e74657200000000000000000000000000006064820152608401610806565b6060600f80546106fd90613031565b60608161225657505060408051808201909152600181527f3000000000000000000000000000000000000000000000000000000000000000602082015290565b8160005b8115612280578061226a8161307f565b91506122799050600a83612f9d565b915061225a565b60008167ffffffffffffffff81111561229b5761229b6131b7565b6040519080825280601f01601f1916602001820160405280156122c5576020820181803683370190505b5090505b8415611d86576122da600183612fee565b91506122e7600a866130b8565b6122f2906030612f85565b60f81b81838151811061230757612307613188565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a905350612341600a86612f9d565b94506122c9565b60007fffffffff0000000000000000000000000000000000000000000000000000000082167f80ac58cd0000000000000000000000000000000000000000000000000000000014806123db57507fffffffff0000000000000000000000000000000000000000000000000000000082167f5b5e139f00000000000000000000000000000000000000000000000000000000145b806106e857507f01ffc9a7000000000000000000000000000000000000000000000000000000007fffffffff000000000000000000000000000000000000000000000000000000008316146106e8565b6001600160a01b0383166124865761248181600880546000838152600960205260408120829055600182018355919091527ff3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee30155565b6124a9565b816001600160a01b0316836001600160a01b0316146124a9576124a98382612737565b6001600160a01b0382166124c057610958816127d4565b826001600160a01b0316826001600160a01b031614610958576109588282612883565b6124ed83836128c7565b6124fa600084848461256c565b6109585760405162461bcd60e51b815260206004820152603260248201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560448201527f63656976657220696d706c656d656e74657200000000000000000000000000006064820152608401610806565b60006001600160a01b0384163b1561272c576040517f150b7a020000000000000000000000000000000000000000000000000000000081526001600160a01b0385169063150b7a02906125c9903390899088908890600401612ea6565b602060405180830381600087803b1580156125e357600080fd5b505af1925050508015612631575060408051601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016820190925261262e91810190612d8c565b60015b6126e1573d80801561265f576040519150601f19603f3d011682016040523d82523d6000602084013e612664565b606091505b5080516126d95760405162461bcd60e51b815260206004820152603260248201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560448201527f63656976657220696d706c656d656e74657200000000000000000000000000006064820152608401610806565b805181602001fd5b7fffffffff00000000000000000000000000000000000000000000000000000000167f150b7a0200000000000000000000000000000000000000000000000000000000149050611d86565b506001949350505050565b60006001612744846112e5565b61274e9190612fee565b6000838152600760205260409020549091508082146127a1576001600160a01b03841660009081526006602090815260408083208584528252808320548484528184208190558352600790915290208190555b5060009182526007602090815260408084208490556001600160a01b039094168352600681528383209183525290812055565b6008546000906127e690600190612fee565b6000838152600960205260408120546008805493945090928490811061280e5761280e613188565b90600052602060002001549050806008838154811061282f5761282f613188565b600091825260208083209091019290925582815260099091526040808220849055858252812055600880548061286757612867613159565b6001900381819060005260206000200160009055905550505050565b600061288e836112e5565b6001600160a01b039093166000908152600660209081526040808320868452825280832085905593825260079052919091209190915550565b6001600160a01b03821661291d5760405162461bcd60e51b815260206004820181905260248201527f4552433732313a206d696e7420746f20746865207a65726f20616464726573736044820152606401610806565b6000818152600260205260409020546001600160a01b0316156129825760405162461bcd60e51b815260206004820152601c60248201527f4552433732313a20746f6b656e20616c7265616479206d696e746564000000006044820152606401610806565b61298e6000838361242b565b6001600160a01b03821660009081526003602052604081208054600192906129b7908490612f85565b909155505060008181526002602052604080822080547fffffffffffffffffffffffff0000000000000000000000000000000000000000166001600160a01b03861690811790915590518392907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a45050565b828054612a3990613031565b90600052602060002090601f016020900481019282612a5b5760008555612aa1565b82601f10612a7457805160ff1916838001178555612aa1565b82800160010185558215612aa1579182015b82811115612aa1578251825591602001919060010190612a86565b50612aad929150612ab1565b5090565b5b80821115612aad5760008155600101612ab2565b600067ffffffffffffffff831115612ae057612ae06131b7565b612b1160207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f86011601612f36565b9050828152838383011115612b2557600080fd5b828260208301376000602084830101529392505050565b80356001600160a01b0381168114612b5357600080fd5b919050565b600060208284031215612b6a57600080fd5b61186682612b3c565b60008060408385031215612b8657600080fd5b612b8f83612b3c565b9150610b5660208401612b3c565b600080600060608486031215612bb257600080fd5b612bbb84612b3c565b9250612bc960208501612b3c565b9150604084013590509250925092565b60008060008060808587031215612bef57600080fd5b612bf885612b3c565b9350612c0660208601612b3c565b925060408501359150606085013567ffffffffffffffff811115612c2957600080fd5b8501601f81018713612c3a57600080fd5b612c4987823560208401612ac6565b91505092959194509250565b60008060408385031215612c6857600080fd5b612c7183612b3c565b915060208301358015158114612c8657600080fd5b809150509250929050565b60008060408385031215612ca457600080fd5b612cad83612b3c565b946020939093013593505050565b60006020808385031215612cce57600080fd5b823567ffffffffffffffff80821115612ce657600080fd5b818501915085601f830112612cfa57600080fd5b813581811115612d0c57612d0c6131b7565b8060051b9150612d1d848301612f36565b8181528481019084860184860187018a1015612d3857600080fd5b600095505b83861015612d6257612d4e81612b3c565b835260019590950194918601918601612d3d565b5098975050505050505050565b600060208284031215612d8157600080fd5b8135611866816131e6565b600060208284031215612d9e57600080fd5b8151611866816131e6565b600060208284031215612dbb57600080fd5b813567ffffffffffffffff811115612dd257600080fd5b8201601f81018413612de357600080fd5b611d8684823560208401612ac6565b600060208284031215612e0457600080fd5b5035919050565b60008060408385031215612e1e57600080fd5b50508035926020909101359150565b60008151808452612e45816020860160208601613005565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b60008351612e89818460208801613005565b835190830190612e9d818360208801613005565b01949350505050565b60006001600160a01b03808716835280861660208401525083604083015260806060830152612ed86080830184612e2d565b9695505050505050565b6020810160038310612f1d577f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b91905290565b6020815260006118666020830184612e2d565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff81118282101715612f7d57612f7d6131b7565b604052919050565b60008219821115612f9857612f986130cc565b500190565b600082612fac57612fac6130fb565b500490565b6000817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0483118215151615612fe957612fe96130cc565b500290565b600082821015613000576130006130cc565b500390565b60005b83811015613020578181015183820152602001613008565b8381111561177e5750506000910152565b600181811c9082168061304557607f821691505b6020821081141561205f577f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8214156130b1576130b16130cc565b5060010190565b6000826130c7576130c76130fb565b500690565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b7fffffffff000000000000000000000000000000000000000000000000000000008116811461321457600080fd5b5056fea26469706673582212200a55ede0bc4a254f257d17f9b12fd89172fdd2d9fb97d1fc6777653bb1b247a264736f6c63430008070033

57924:6738:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52863:190;;;;;;;;;;-1:-1:-1;52863:190:0;;;;;:::i;:::-;;:::i;:::-;;;7341:14:1;;7334:22;7316:41;;7304:2;7289:18;52863:190:0;;;;;;;;58349:46;;;;;;;;;;;;58386:9;58349:46;;;;;19108:25:1;;;19096:2;19081:18;58349:46:0;18962:177:1;24255:100:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;25814:221::-;;;;;;;;;;-1:-1:-1;25814:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;6291:55:1;;;6273:74;;6261:2;6246:18;25814:221:0;6127:226:1;25337:411:0;;;;;;;;;;-1:-1:-1;25337:411:0;;;;;:::i;:::-;;:::i;:::-;;61902:152;;;;;;;;;;-1:-1:-1;61902:152:0;;;;;:::i;:::-;;:::i;61043:123::-;;;;;;;;;;-1:-1:-1;61043:123:0;;;;;:::i;:::-;;:::i;62925:125::-;;;;;;;;;;;;;:::i;26704:339::-;;;;;;;;;;-1:-1:-1;26704:339:0;;;;;:::i;:::-;;:::i;58654:51::-;;;;;;;;;;-1:-1:-1;58654:51:0;;;;;:::i;:::-;;;;;;;;;;;;;;56330:239;;;;;;;;;;-1:-1:-1;56330:239:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;7066:55:1;;;7048:74;;7153:2;7138:18;;7131:34;;;;7021:18;56330:239:0;6874:297:1;61407:181:0;;;;;;;;;;-1:-1:-1;61407:181:0;;;;;:::i;:::-;;:::i;39535:256::-;;;;;;;;;;-1:-1:-1;39535:256:0;;;;;:::i;:::-;;:::i;58402:46::-;;;;;;;;;;;;58447:1;58402:46;;27114:185;;;;;;;;;;-1:-1:-1;27114:185:0;;;;;:::i;:::-;;:::i;61596:298::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;40057:233::-;;;;;;;;;;-1:-1:-1;40057:233:0;;;;;:::i;:::-;;:::i;62404:513::-;;;:::i;61291:108::-;;;;;;;;;;-1:-1:-1;61291:108:0;;;;;:::i;:::-;;:::i;23949:239::-;;;;;;;;;;-1:-1:-1;23949:239:0;;;;;:::i;:::-;;:::i;58222:29::-;;;;;;;;;;;;;:::i;58547:61::-;;;;;;;;;;;;;;;;23679:208;;;;;;;;;;-1:-1:-1;23679:208:0;;;;;:::i;:::-;;:::i;58303:39::-;;;;;;;;;;;;58338:4;58303:39;;63427:1077;;;;;;;;;;;;;:::i;24424:104::-;;;;;;;;;;;;;:::i;26107:295::-;;;;;;;;;;-1:-1:-1;26107:295:0;;;;;:::i;:::-;;:::i;58457:41::-;;;;;;;;;;;;;;;;27370:328;;;;;;;;;;-1:-1:-1;27370:328:0;;;;;:::i;:::-;;:::i;24599:334::-;;;;;;;;;;-1:-1:-1;24599:334:0;;;;;:::i;:::-;;:::i;58712:52::-;;;;;;;;;;-1:-1:-1;58712:52:0;;;;;:::i;:::-;;;;;;;;;;;;;;26473:164;;;;;;;;;;-1:-1:-1;26473:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;26594:25:0;;;26570:4;26594:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;26473:164;58819:45;;;;;;;;;;-1:-1:-1;58819:45:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;62062:334;;;;;;;;;;;;;:::i;52863:190::-;52948:4;52972:36;52996:11;52972:23;:36::i;:::-;:73;;;-1:-1:-1;53012:33:0;;;;;;;:20;:33;;;;;;;;52972:73;52965:80;52863:190;-1:-1:-1;;52863:190:0:o;24255:100::-;24309:13;24342:5;24335:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24255:100;:::o;25814:221::-;25890:7;29297:16;;;:7;:16;;;;;;-1:-1:-1;;;;;29297:16:0;25910:73;;;;-1:-1:-1;;;25910:73:0;;16004:2:1;25910:73:0;;;15986:21:1;16043:2;16023:18;;;16016:30;16082:34;16062:18;;;16055:62;16153:14;16133:18;;;16126:42;16185:19;;25910:73:0;;;;;;;;;-1:-1:-1;26003:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;26003:24:0;;25814:221::o;25337:411::-;25418:13;25434:23;25449:7;25434:14;:23::i;:::-;25418:39;;25482:5;-1:-1:-1;;;;;25476:11:0;:2;-1:-1:-1;;;;;25476:11:0;;;25468:57;;;;-1:-1:-1;;;25468:57:0;;17243:2:1;25468:57:0;;;17225:21:1;17282:2;17262:18;;;17255:30;17321:34;17301:18;;;17294:62;17392:3;17372:18;;;17365:31;17413:19;;25468:57:0;17041:397:1;25468:57:0;18861:10;-1:-1:-1;;;;;25560:21:0;;;;:62;;-1:-1:-1;25585:37:0;25602:5;18861:10;26473:164;:::i;25585:37::-;25538:168;;;;-1:-1:-1;;;25538:168:0;;12912:2:1;25538:168:0;;;12894:21:1;12951:2;12931:18;;;12924:30;12990:34;12970:18;;;12963:62;13061:26;13041:18;;;13034:54;13105:19;;25538:168:0;12710:420:1;25538:168:0;25719:21;25728:2;25732:7;25719:8;:21::i;:::-;25407:341;25337:411;;:::o;61902:152::-;59902:10;59895:18;;;;:6;:18;;;;;;;;59887:74;;;;-1:-1:-1;;;59887:74:0;;9383:2:1;59887:74:0;;;9365:21:1;9422:2;9402:18;;;9395:30;9461:34;9441:18;;;9434:62;9532:13;9512:18;;;9505:41;9563:19;;59887:74:0;9181:407:1;59887:74:0;61968:16:::1;:27:::0;;;62028:18:::1;61987:8:::0;62039:7:::1;62028:18;:::i;:::-;62006:19;:40:::0;-1:-1:-1;61902:152:0:o;61043:123::-;59902:10;59895:18;;;;:6;:18;;;;;;;;59887:74;;;;-1:-1:-1;;;59887:74:0;;9383:2:1;59887:74:0;;;9365:21:1;9422:2;9402:18;;;9395:30;9461:34;9441:18;;;9434:62;9532:13;9512:18;;;9505:41;9563:19;;59887:74:0;9181:407:1;59887:74:0;61130:28;;::::1;::::0;:10:::1;::::0;:28:::1;::::0;::::1;::::0;::::1;:::i;:::-;;61043:123:::0;:::o;62925:125::-;62996:7;63023:19;39955:10;:17;;39867:113;63023:19;63016:26;;62925:125;:::o;26704:339::-;26899:41;18861:10;26932:7;26899:18;:41::i;:::-;26891:103;;;;-1:-1:-1;;;26891:103:0;;17645:2:1;26891:103:0;;;17627:21:1;17684:2;17664:18;;;17657:30;17723:34;17703:18;;;17696:62;17794:19;17774:18;;;17767:47;17831:19;;26891:103:0;17443:413:1;26891:103:0;27007:28;27017:4;27023:2;27027:7;27007:9;:28::i;56330:239::-;56490:8;;56545:17;;-1:-1:-1;;;;;56490:8:0;;;;56431:16;;56521:42;;:19;:10;56536:3;56521:14;:19::i;:::-;:23;;:42::i;:::-;56505:58;;56330:239;;;;;:::o;61407:181::-;59902:10;59895:18;;;;:6;:18;;;;;;;;59887:74;;;;-1:-1:-1;;;59887:74:0;;9383:2:1;59887:74:0;;;9365:21:1;9422:2;9402:18;;;9395:30;9461:34;9441:18;;;9434:62;9532:13;9512:18;;;9505:41;9563:19;;59887:74:0;9181:407:1;59887:74:0;61490:6:::1;61486:95;61506:5;:12;61502:1;:16;61486:95;;;61565:4;61539:13;:23;61553:5;61559:1;61553:8;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;-1:-1:-1;;;;;61539:23:0::1;::::0;;;::::1;::::0;;;;;;-1:-1:-1;61539:23:0;:30;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;61520:3;::::1;::::0;::::1;:::i;:::-;;;;61486:95;;39535:256:::0;39632:7;39668:23;39685:5;39668:16;:23::i;:::-;39660:5;:31;39652:87;;;;-1:-1:-1;;;39652:87:0;;8195:2:1;39652:87:0;;;8177:21:1;8234:2;8214:18;;;8207:30;8273:34;8253:18;;;8246:62;8344:13;8324:18;;;8317:41;8375:19;;39652:87:0;7993:407:1;39652:87:0;-1:-1:-1;;;;;;39757:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;39535:256::o;27114:185::-;27252:39;27269:4;27275:2;27279:7;27252:39;;;;;;;;;;;;:16;:39::i;61596:298::-;61638:6;61679:19;;61660:15;:38;61657:199;;-1:-1:-1;61722:22:0;;61596:298::o;61657:199::-;61785:16;;61766:15;:35;61762:94;;-1:-1:-1;61825:19:0;;61596:298::o;61762:94::-;-1:-1:-1;61873:13:0;;61596:298::o;40057:233::-;40132:7;40168:30;39955:10;:17;;39867:113;40168:30;40160:5;:38;40152:95;;;;-1:-1:-1;;;40152:95:0;;18399:2:1;40152:95:0;;;18381:21:1;18438:2;18418:18;;;18411:30;18477:34;18457:18;;;18450:62;18548:14;18528:18;;;18521:42;18580:19;;40152:95:0;18197:408:1;40152:95:0;40265:10;40276:5;40265:17;;;;;;;;:::i;:::-;;;;;;;;;40258:24;;40057:233;;;:::o;62404:513::-;62454:10;60625:22;60610:11;:9;:11::i;:::-;:37;;;;;;;;:::i;:::-;;60602:77;;;;-1:-1:-1;;;60602:77:0;;9795:2:1;60602:77:0;;;9777:21:1;9834:2;9814:18;;;9807:30;9873:29;9853:18;;;9846:57;9920:18;;60602:77:0;9593:351:1;60602:77:0;60715:9;58386;60698:26;;60690:65;;;;-1:-1:-1;;;60690:65:0;;14158:2:1;60690:65:0;;;14140:21:1;14197:2;14177:18;;;14170:30;14236:28;14216:18;;;14209:56;14282:18;;60690:65:0;13956:350:1;60690:65:0;58338:4;60774:13;:11;:13::i;:::-;:27;60766:48;;;;-1:-1:-1;;;60766:48:0;;18063:2:1;60766:48:0;;;18045:21:1;18102:1;18082:18;;;18075:29;18140:10;18120:18;;;18113:38;18168:18;;60766:48:0;17861:331:1;60766:48:0;58338:4;60833:20;60851:1;60833:13;:11;:13::i;:::-;:17;;:20::i;:::-;:35;;60825:80;;;;-1:-1:-1;;;60825:80:0;;14513:2:1;60825:80:0;;;14495:21:1;;;14532:18;;;14525:30;14591:34;14571:18;;;14564:62;14643:18;;60825:80:0;14311:356:1;60825:80:0;60945:10;60924:32;;;;:20;:32;;;;;;58447:1;-1:-1:-1;60916:99:0;;;;-1:-1:-1;;;60916:99:0;;14874:2:1;60916:99:0;;;14856:21:1;14913:2;14893:18;;;14886:30;14952:32;14932:18;;;14925:60;15002:18;;60916:99:0;14672:354:1;60916:99:0;62491:10:::1;62514:21;:9;2426:19:::0;;2444:1;2426:19;;;2337:127;62514:21:::1;62546:11;62560:19;:9;2307:14:::0;;2215:114;62560:19:::1;62546:33;;62592:22;62602:3;62607:6;62592:9;:22::i;:::-;-1:-1:-1::0;;;;;62625:25:0;::::1;;::::0;;;:20:::1;:25;::::0;;;;:27;;;::::1;::::0;::::1;:::i;:::-;;;;;;62671:5;62677:1;62671:8;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;62671:8:0::1;62663:60;62690:32;62704:17;:9;62718:2;62704:13;:17::i;:::-;62690:9;::::0;:13:::1;:32::i;:::-;62663:60;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;62787:5;62793:1;62787:8;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;62787:8:0::1;62779:45;62806:17;:9;62820:2;62806:13;:17::i;:::-;62779:45;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;::::1;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;62884:25:0::1;::::0;;19318::1;;;-1:-1:-1;;;;;19379:55:1;;19374:2;19359:18;;19352:83;62884:25:0::1;::::0;19291:18:1;62884:25:0::1;;;;;;;;62466:451;;62404:513:::0;:::o;61291:108::-;59902:10;59895:18;;;;:6;:18;;;;;;;;59887:74;;;;-1:-1:-1;;;59887:74:0;;9383:2:1;59887:74:0;;;9365:21:1;9422:2;9402:18;;;9395:30;9461:34;9441:18;;;9434:62;9532:13;9512:18;;;9505:41;9563:19;;59887:74:0;9181:407:1;59887:74:0;61364:27;;::::1;::::0;:16:::1;::::0;:27:::1;::::0;::::1;::::0;::::1;:::i;23949:239::-:0;24021:7;24057:16;;;:7;:16;;;;;;-1:-1:-1;;;;;24057:16:0;24092:19;24084:73;;;;-1:-1:-1;;;24084:73:0;;13748:2:1;24084:73:0;;;13730:21:1;13787:2;13767:18;;;13760:30;13826:34;13806:18;;;13799:62;13897:11;13877:18;;;13870:39;13926:19;;24084:73:0;13546:405:1;58222:29:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;23679:208::-;23751:7;-1:-1:-1;;;;;23779:19:0;;23771:74;;;;-1:-1:-1;;;23771:74:0;;13337:2:1;23771:74:0;;;13319:21:1;13376:2;13356:18;;;13349:30;13415:34;13395:18;;;13388:62;13486:12;13466:18;;;13459:40;13516:19;;23771:74:0;13135:406:1;23771:74:0;-1:-1:-1;;;;;;23863:16:0;;;;;:9;:16;;;;;;;23679:208::o;63427:1077::-;59902:10;59895:18;;;;:6;:18;;;;;;;;59887:74;;;;-1:-1:-1;;;59887:74:0;;9383:2:1;59887:74:0;;;9365:21:1;9422:2;9402:18;;;9395:30;9461:34;9441:18;;;9434:62;9532:13;9512:18;;;9505:41;9563:19;;59887:74:0;9181:407:1;59887:74:0;63509:1:::1;63485:21;:25;63477:71;;;::::0;-1:-1:-1;;;63477:71:0;;10151:2:1;63477:71:0::1;::::0;::::1;10133:21:1::0;10190:2;10170:18;;;10163:30;10229:34;10209:18;;;10202:62;10300:3;10280:18;;;10273:31;10321:19;;63477:71:0::1;9949:397:1::0;63477:71:0::1;63561:19;63583:24;:22;:24::i;:::-;63561:46:::0;-1:-1:-1;63644:21:0::1;63620;63678:238;63699:5;:12:::0;63695:16;::::1;63678:238;;;63733:22;63766:5;63772:1;63766:8;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;::::1;::::0;63825:12:::1;:15:::0;;-1:-1:-1;;;;;63766:8:0;;::::1;::::0;-1:-1:-1;63844:11:0;;63838:1;;63825:15;::::1;;;;;:::i;:::-;;;;;;;;;63809:13;:31;;;;:::i;:::-;63808:47;;;;:::i;:::-;63790:65;;63870:34;63888:6;63896:7;63870:17;:34::i;:::-;63718:198;;63713:3;;;;;:::i;:::-;;;;63678:238;;;;63931:6;63926:571;63947:9;:16:::0;63943:20;::::1;63926:571;;;63985:22;64042:9;64052:1;64042:12;;;;;;;;:::i;:::-;;;;;;;;;64026:13;:11;:13::i;:::-;:28;64022:331;;;64190:5;64196:1;64190:8;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;64190:8:0::1;::::0;-1:-1:-1;64022:331:0::1;;;64315:21;64323:9;64333:1;64323:12;;;;;;;;:::i;:::-;;;;;;;;;64315:7;:21::i;:::-;64298:39;;64022:331;64367:15;64425:11;64402:16;64419:1;64402:19;;;;;;;;:::i;:::-;;;;;;;;;64386:13;:35;;;;:::i;:::-;64385:51;;;;:::i;:::-;64367:69;;64451:34;64469:6;64477:7;64451:17;:34::i;:::-;63970:527;;63965:3;;;;;:::i;:::-;;;;63926:571;;24424:104:::0;24480:13;24513:7;24506:14;;;;;:::i;26107:295::-;-1:-1:-1;;;;;26210:24:0;;18861:10;26210:24;;26202:62;;;;-1:-1:-1;;;26202:62:0;;10958:2:1;26202:62:0;;;10940:21:1;10997:2;10977:18;;;10970:30;11036:27;11016:18;;;11009:55;11081:18;;26202:62:0;10756:349:1;26202:62:0;18861:10;26277:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;26277:42:0;;;;;;;;;;;;:53;;;;;;;;;;;;;26346:48;;7316:41:1;;;26277:42:0;;18861:10;26346:48;;7289:18:1;26346:48:0;;;;;;;26107:295;;:::o;27370:328::-;27545:41;18861:10;27578:7;27545:18;:41::i;:::-;27537:103;;;;-1:-1:-1;;;27537:103:0;;17645:2:1;27537:103:0;;;17627:21:1;17684:2;17664:18;;;17657:30;17723:34;17703:18;;;17696:62;17794:19;17774:18;;;17767:47;17831:19;;27537:103:0;17443:413:1;27537:103:0;27651:39;27665:4;27671:2;27675:7;27684:5;27651:13;:39::i;:::-;27370:328;;;;:::o;24599:334::-;29273:4;29297:16;;;:7;:16;;;;;;24672:13;;-1:-1:-1;;;;;29297:16:0;24698:76;;;;-1:-1:-1;;;24698:76:0;;16827:2:1;24698:76:0;;;16809:21:1;16866:2;16846:18;;;16839:30;16905:34;16885:18;;;16878:62;16976:17;16956:18;;;16949:45;17011:19;;24698:76:0;16625:411:1;24698:76:0;24787:21;24811:10;:8;:10::i;:::-;24787:34;;24863:1;24845:7;24839:21;:25;:86;;;;;;;;;;;;;;;;;24891:7;24900:18;:7;:16;:18::i;:::-;24874:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;24839:86;24832:93;24599:334;-1:-1:-1;;;24599:334:0:o;62062:::-;62112:10;60045:18;;;;:13;:18;;;;;;;;;:40;;-1:-1:-1;60074:10:0;60067:18;;;;:6;:18;;;;;;;;60045:40;60037:94;;;;-1:-1:-1;;;60037:94:0;;15594:2:1;60037:94:0;;;15576:21:1;15633:2;15613:18;;;15606:30;15672:34;15652:18;;;15645:62;15743:11;15723:18;;;15716:39;15772:19;;60037:94:0;15392:405:1;60037:94:0;-1:-1:-1;;;;;60150:24:0;;;;;;:19;:24;;;;;;:29;60142:75;;;;-1:-1:-1;;;60142:75:0;;12510:2:1;60142:75:0;;;12492:21:1;12549:2;12529:18;;;12522:30;12588:34;12568:18;;;12561:62;12659:3;12639:18;;;12632:31;12680:19;;60142:75:0;12308:397:1;60142:75:0;60251:19;60236:11;:9;:11::i;:::-;:34;;;;;;;;:::i;:::-;;:75;;;-1:-1:-1;60289:22:0;60274:11;:9;:11::i;:::-;:37;;;;;;;;:::i;:::-;;60236:75;:97;;;-1:-1:-1;60322:10:0;60315:18;;;;:6;:18;;;;;;;;60236:97;60228:133;;;;-1:-1:-1;;;60228:133:0;;18812:2:1;60228:133:0;;;18794:21:1;18851:2;18831:18;;;18824:30;18890:25;18870:18;;;18863:53;18933:18;;60228:133:0;18610:347:1;60228:133:0;58338:4;60380:13;:11;:13::i;:::-;:27;60372:48;;;;-1:-1:-1;;;60372:48:0;;18063:2:1;60372:48:0;;;18045:21:1;18102:1;18082:18;;;18075:29;18140:10;18120:18;;;18113:38;18168:18;;60372:48:0;17861:331:1;60372:48:0;60460:10;60439:32;;;;:20;:32;;;;;;58447:1;-1:-1:-1;60431:99:0;;;;-1:-1:-1;;;60431:99:0;;14874:2:1;60431:99:0;;;14856:21:1;14913:2;14893:18;;;14886:30;14952:32;14932:18;;;14925:60;15002:18;;60431:99:0;14672:354:1;60431:99:0;62149:10:::1;62172:21;:9;2426:19:::0;;2444:1;2426:19;;;2337:127;62172:21:::1;62204:11;62218:19;:9;2307:14:::0;;2215:114;62218:19:::1;62204:33;;62250:22;62260:3;62265:6;62250:9;:22::i;:::-;-1:-1:-1::0;;;;;62283:25:0;::::1;;::::0;;;:20:::1;:25;::::0;;;;:27;;;::::1;::::0;::::1;:::i;:::-;::::0;;;-1:-1:-1;;;;;;;62321:24:0;::::1;;::::0;;;:19:::1;:24;::::0;;;;:26;;;::::1;::::0;::::1;:::i;:::-;::::0;;;-1:-1:-1;;62363:25:0::1;::::0;;19318::1;;;-1:-1:-1;;;;;19379:55:1;;19374:2;19359:18;;19352:83;62363:25:0::1;::::0;19291:18:1;62363:25:0::1;19144:297:1::0;39227:224:0;39329:4;39353:50;;;39368:35;39353:50;;:90;;;39407:36;39431:11;39407:23;:36::i;33190:174::-;33265:24;;;;:15;:24;;;;;:29;;;;-1:-1:-1;;;;;33265:29:0;;;;;;;;:24;;33319:23;33265:24;33319:14;:23::i;:::-;-1:-1:-1;;;;;33310:46:0;;;;;;;;;;;33190:174;;:::o;29502:348::-;29595:4;29297:16;;;:7;:16;;;;;;-1:-1:-1;;;;;29297:16:0;29612:73;;;;-1:-1:-1;;;29612:73:0;;12097:2:1;29612:73:0;;;12079:21:1;12136:2;12116:18;;;12109:30;12175:34;12155:18;;;12148:62;12246:14;12226:18;;;12219:42;12278:19;;29612:73:0;11895:408:1;29612:73:0;29696:13;29712:23;29727:7;29712:14;:23::i;:::-;29696:39;;29765:5;-1:-1:-1;;;;;29754:16:0;:7;-1:-1:-1;;;;;29754:16:0;;:51;;;;29798:7;-1:-1:-1;;;;;29774:31:0;:20;29786:7;29774:11;:20::i;:::-;-1:-1:-1;;;;;29774:31:0;;29754:51;:87;;;-1:-1:-1;;;;;;26594:25:0;;;26570:4;26594:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;29809:32;29746:96;29502:348;-1:-1:-1;;;;29502:348:0:o;32494:578::-;32653:4;-1:-1:-1;;;;;32626:31:0;:23;32641:7;32626:14;:23::i;:::-;-1:-1:-1;;;;;32626:31:0;;32618:85;;;;-1:-1:-1;;;32618:85:0;;16417:2:1;32618:85:0;;;16399:21:1;16456:2;16436:18;;;16429:30;16495:34;16475:18;;;16468:62;16566:11;16546:18;;;16539:39;16595:19;;32618:85:0;16215:405:1;32618:85:0;-1:-1:-1;;;;;32722:16:0;;32714:65;;;;-1:-1:-1;;;32714:65:0;;10553:2:1;32714:65:0;;;10535:21:1;10592:2;10572:18;;;10565:30;10631:34;10611:18;;;10604:62;10702:6;10682:18;;;10675:34;10726:19;;32714:65:0;10351:400:1;32714:65:0;32792:39;32813:4;32819:2;32823:7;32792:20;:39::i;:::-;32896:29;32913:1;32917:7;32896:8;:29::i;:::-;-1:-1:-1;;;;;32938:15:0;;;;;;:9;:15;;;;;:20;;32957:1;;32938:15;:20;;32957:1;;32938:20;:::i;:::-;;;;-1:-1:-1;;;;;;;32969:13:0;;;;;;:9;:13;;;;;:18;;32986:1;;32969:13;:18;;32986:1;;32969:18;:::i;:::-;;;;-1:-1:-1;;32998:16:0;;;;:7;:16;;;;;;:21;;;;-1:-1:-1;;;;;32998:21:0;;;;;;;;;33037:27;;32998:16;;33037:27;;;;;;;32494:578;;;:::o;49289:98::-;49347:7;49374:5;49378:1;49374;:5;:::i;48890:98::-;48948:7;48975:5;48979:1;48975;:5;:::i;48152:98::-;48210:7;48237:5;48241:1;48237;:5;:::i;30192:110::-;30268:26;30278:2;30282:7;30268:26;;;;;;;;;;;;:9;:26::i;48533:98::-;48591:7;48618:5;48622:1;48618;:5;:::i;63060:359::-;63117:7;;;63171:97;63192:5;:12;63188:16;;63171:97;;;63241:12;63254:1;63241:15;;;;;;;;:::i;:::-;;;;;;;;;63226:30;;;;;:::i;:::-;;-1:-1:-1;63206:3:0;;;;:::i;:::-;;;;63171:97;;;;63283:6;63278:105;63299:9;:16;63295:20;;63278:105;;;63352:16;63369:1;63352:19;;;;;;;;:::i;:::-;;;;;;;;;63337:34;;;;;:::i;:::-;;-1:-1:-1;63317:3:0;;;;:::i;:::-;;;;63278:105;;;-1:-1:-1;63400:11:0;63060:359;-1:-1:-1;63060:359:0:o;12162:317::-;12277:6;12252:21;:31;;12244:73;;;;-1:-1:-1;;;12244:73:0;;11739:2:1;12244:73:0;;;11721:21:1;11778:2;11758:18;;;11751:30;11817:31;11797:18;;;11790:59;11866:18;;12244:73:0;11537:353:1;12244:73:0;12331:12;12349:9;-1:-1:-1;;;;;12349:14:0;12371:6;12349:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12330:52;;;12401:7;12393:78;;;;-1:-1:-1;;;12393:78:0;;11312:2:1;12393:78:0;;;11294:21:1;11351:2;11331:18;;;11324:30;11390:34;11370:18;;;11363:62;11461:28;11441:18;;;11434:56;11507:19;;12393:78:0;11110:422:1;28580:315:0;28737:28;28747:4;28753:2;28757:7;28737:9;:28::i;:::-;28784:48;28807:4;28813:2;28817:7;28826:5;28784:22;:48::i;:::-;28776:111;;;;-1:-1:-1;;;28776:111:0;;8607:2:1;28776:111:0;;;8589:21:1;8646:2;8626:18;;;8619:30;8685:34;8665:18;;;8658:62;8756:20;8736:18;;;8729:48;8794:19;;28776:111:0;8405:414:1;61174:109:0;61226:13;61259:16;61252:23;;;;;:::i;19291:723::-;19347:13;19568:10;19564:53;;-1:-1:-1;;19595:10:0;;;;;;;;;;;;;;;;;;19291:723::o;19564:53::-;19642:5;19627:12;19683:78;19690:9;;19683:78;;19716:8;;;;:::i;:::-;;-1:-1:-1;19739:10:0;;-1:-1:-1;19747:2:0;19739:10;;:::i;:::-;;;19683:78;;;19771:19;19803:6;19793:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;19793:17:0;;19771:39;;19821:154;19828:10;;19821:154;;19855:11;19865:1;19855:11;;:::i;:::-;;-1:-1:-1;19924:10:0;19932:2;19924:5;:10;:::i;:::-;19911:24;;:2;:24;:::i;:::-;19898:39;;19881:6;19888;19881:14;;;;;;;;:::i;:::-;;;;:56;;;;;;;;;;-1:-1:-1;19952:11:0;19961:2;19952:11;;:::i;:::-;;;19821:154;;23310:305;23412:4;23449:40;;;23464:25;23449:40;;:105;;-1:-1:-1;23506:48:0;;;23521:33;23506:48;23449:105;:158;;;-1:-1:-1;21955:25:0;21940:40;;;;23571:36;21831:157;40903:589;-1:-1:-1;;;;;41109:18:0;;41105:187;;41144:40;41176:7;42319:10;:17;;42292:24;;;;:15;:24;;;;;:44;;;42347:24;;;;;;;;;;;;42215:164;41144:40;41105:187;;;41214:2;-1:-1:-1;;;;;41206:10:0;:4;-1:-1:-1;;;;;41206:10:0;;41202:90;;41233:47;41266:4;41272:7;41233:32;:47::i;:::-;-1:-1:-1;;;;;41306:16:0;;41302:183;;41339:45;41376:7;41339:36;:45::i;41302:183::-;41412:4;-1:-1:-1;;;;;41406:10:0;:2;-1:-1:-1;;;;;41406:10:0;;41402:83;;41433:40;41461:2;41465:7;41433:27;:40::i;30529:321::-;30659:18;30665:2;30669:7;30659:5;:18::i;:::-;30710:54;30741:1;30745:2;30749:7;30758:5;30710:22;:54::i;:::-;30688:154;;;;-1:-1:-1;;;30688:154:0;;8607:2:1;30688:154:0;;;8589:21:1;8646:2;8626:18;;;8619:30;8685:34;8665:18;;;8658:62;8756:20;8736:18;;;8729:48;8794:19;;30688:154:0;8405:414:1;33929:799:0;34084:4;-1:-1:-1;;;;;34105:13:0;;11163:20;11211:8;34101:620;;34141:72;;;;;-1:-1:-1;;;;;34141:36:0;;;;;:72;;18861:10;;34192:4;;34198:7;;34207:5;;34141:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;34141:72:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;34137:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;34383:13:0;;34379:272;;34426:60;;-1:-1:-1;;;34426:60:0;;8607:2:1;34426:60:0;;;8589:21:1;8646:2;8626:18;;;8619:30;8685:34;8665:18;;;8658:62;8756:20;8736:18;;;8729:48;8794:19;;34426:60:0;8405:414:1;34379:272:0;34601:6;34595:13;34586:6;34582:2;34578:15;34571:38;34137:529;34264:51;;34274:41;34264:51;;-1:-1:-1;34257:58:0;;34101:620;-1:-1:-1;34705:4:0;33929:799;;;;;;:::o;43006:988::-;43272:22;43322:1;43297:22;43314:4;43297:16;:22::i;:::-;:26;;;;:::i;:::-;43334:18;43355:26;;;:17;:26;;;;;;43272:51;;-1:-1:-1;43488:28:0;;;43484:328;;-1:-1:-1;;;;;43555:18:0;;43533:19;43555:18;;;:12;:18;;;;;;;;:34;;;;;;;;;43606:30;;;;;;:44;;;43723:30;;:17;:30;;;;;:43;;;43484:328;-1:-1:-1;43908:26:0;;;;:17;:26;;;;;;;;43901:33;;;-1:-1:-1;;;;;43952:18:0;;;;;:12;:18;;;;;:34;;;;;;;43945:41;43006:988::o;44289:1079::-;44567:10;:17;44542:22;;44567:21;;44587:1;;44567:21;:::i;:::-;44599:18;44620:24;;;:15;:24;;;;;;44993:10;:26;;44542:46;;-1:-1:-1;44620:24:0;;44542:46;;44993:26;;;;;;:::i;:::-;;;;;;;;;44971:48;;45057:11;45032:10;45043;45032:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;45137:28;;;:15;:28;;;;;;;:41;;;45309:24;;;;;45302:31;45344:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;44360:1008;;;44289:1079;:::o;41793:221::-;41878:14;41895:20;41912:2;41895:16;:20::i;:::-;-1:-1:-1;;;;;41926:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;41971:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;41793:221:0:o;31186:382::-;-1:-1:-1;;;;;31266:16:0;;31258:61;;;;-1:-1:-1;;;31258:61:0;;15233:2:1;31258:61:0;;;15215:21:1;;;15252:18;;;15245:30;15311:34;15291:18;;;15284:62;15363:18;;31258:61:0;15031:356:1;31258:61:0;29273:4;29297:16;;;:7;:16;;;;;;-1:-1:-1;;;;;29297:16:0;:30;31330:58;;;;-1:-1:-1;;;31330:58:0;;9026:2:1;31330:58:0;;;9008:21:1;9065:2;9045:18;;;9038:30;9104;9084:18;;;9077:58;9152:18;;31330:58:0;8824:352:1;31330:58:0;31401:45;31430:1;31434:2;31438:7;31401:20;:45::i;:::-;-1:-1:-1;;;;;31459:13:0;;;;;;:9;:13;;;;;:18;;31476:1;;31459:13;:18;;31476:1;;31459:18;:::i;:::-;;;;-1:-1:-1;;31488:16:0;;;;:7;:16;;;;;;:21;;;;-1:-1:-1;;;;;31488:21:0;;;;;;;;31527:33;;31488:16;;;31527:33;;31488:16;;31527:33;31186:382;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:465:1;78:5;112:18;104:6;101:30;98:56;;;134:18;;:::i;:::-;172:116;282:4;213:66;208:2;200:6;196:15;192:88;188:99;172:116;:::i;:::-;163:125;;311:6;304:5;297:21;351:3;342:6;337:3;333:16;330:25;327:45;;;368:1;365;358:12;327:45;417:6;412:3;405:4;398:5;394:16;381:43;471:1;464:4;455:6;448:5;444:18;440:29;433:40;14:465;;;;;:::o;484:196::-;552:20;;-1:-1:-1;;;;;601:54:1;;591:65;;581:93;;670:1;667;660:12;581:93;484:196;;;:::o;685:186::-;744:6;797:2;785:9;776:7;772:23;768:32;765:52;;;813:1;810;803:12;765:52;836:29;855:9;836:29;:::i;876:260::-;944:6;952;1005:2;993:9;984:7;980:23;976:32;973:52;;;1021:1;1018;1011:12;973:52;1044:29;1063:9;1044:29;:::i;:::-;1034:39;;1092:38;1126:2;1115:9;1111:18;1092:38;:::i;1141:328::-;1218:6;1226;1234;1287:2;1275:9;1266:7;1262:23;1258:32;1255:52;;;1303:1;1300;1293:12;1255:52;1326:29;1345:9;1326:29;:::i;:::-;1316:39;;1374:38;1408:2;1397:9;1393:18;1374:38;:::i;:::-;1364:48;;1459:2;1448:9;1444:18;1431:32;1421:42;;1141:328;;;;;:::o;1474:666::-;1569:6;1577;1585;1593;1646:3;1634:9;1625:7;1621:23;1617:33;1614:53;;;1663:1;1660;1653:12;1614:53;1686:29;1705:9;1686:29;:::i;:::-;1676:39;;1734:38;1768:2;1757:9;1753:18;1734:38;:::i;:::-;1724:48;;1819:2;1808:9;1804:18;1791:32;1781:42;;1874:2;1863:9;1859:18;1846:32;1901:18;1893:6;1890:30;1887:50;;;1933:1;1930;1923:12;1887:50;1956:22;;2009:4;2001:13;;1997:27;-1:-1:-1;1987:55:1;;2038:1;2035;2028:12;1987:55;2061:73;2126:7;2121:2;2108:16;2103:2;2099;2095:11;2061:73;:::i;:::-;2051:83;;;1474:666;;;;;;;:::o;2145:347::-;2210:6;2218;2271:2;2259:9;2250:7;2246:23;2242:32;2239:52;;;2287:1;2284;2277:12;2239:52;2310:29;2329:9;2310:29;:::i;:::-;2300:39;;2389:2;2378:9;2374:18;2361:32;2436:5;2429:13;2422:21;2415:5;2412:32;2402:60;;2458:1;2455;2448:12;2402:60;2481:5;2471:15;;;2145:347;;;;;:::o;2497:254::-;2565:6;2573;2626:2;2614:9;2605:7;2601:23;2597:32;2594:52;;;2642:1;2639;2632:12;2594:52;2665:29;2684:9;2665:29;:::i;:::-;2655:39;2741:2;2726:18;;;;2713:32;;-1:-1:-1;;;2497:254:1:o;2756:963::-;2840:6;2871:2;2914;2902:9;2893:7;2889:23;2885:32;2882:52;;;2930:1;2927;2920:12;2882:52;2970:9;2957:23;2999:18;3040:2;3032:6;3029:14;3026:34;;;3056:1;3053;3046:12;3026:34;3094:6;3083:9;3079:22;3069:32;;3139:7;3132:4;3128:2;3124:13;3120:27;3110:55;;3161:1;3158;3151:12;3110:55;3197:2;3184:16;3219:2;3215;3212:10;3209:36;;;3225:18;;:::i;:::-;3271:2;3268:1;3264:10;3254:20;;3294:28;3318:2;3314;3310:11;3294:28;:::i;:::-;3356:15;;;3387:12;;;;3419:11;;;3449;;;3445:20;;3442:33;-1:-1:-1;3439:53:1;;;3488:1;3485;3478:12;3439:53;3510:1;3501:10;;3520:169;3534:2;3531:1;3528:9;3520:169;;;3591:23;3610:3;3591:23;:::i;:::-;3579:36;;3552:1;3545:9;;;;;3635:12;;;;3667;;3520:169;;;-1:-1:-1;3708:5:1;2756:963;-1:-1:-1;;;;;;;;2756:963:1:o;3724:245::-;3782:6;3835:2;3823:9;3814:7;3810:23;3806:32;3803:52;;;3851:1;3848;3841:12;3803:52;3890:9;3877:23;3909:30;3933:5;3909:30;:::i;3974:249::-;4043:6;4096:2;4084:9;4075:7;4071:23;4067:32;4064:52;;;4112:1;4109;4102:12;4064:52;4144:9;4138:16;4163:30;4187:5;4163:30;:::i;4228:450::-;4297:6;4350:2;4338:9;4329:7;4325:23;4321:32;4318:52;;;4366:1;4363;4356:12;4318:52;4406:9;4393:23;4439:18;4431:6;4428:30;4425:50;;;4471:1;4468;4461:12;4425:50;4494:22;;4547:4;4539:13;;4535:27;-1:-1:-1;4525:55:1;;4576:1;4573;4566:12;4525:55;4599:73;4664:7;4659:2;4646:16;4641:2;4637;4633:11;4599:73;:::i;4683:180::-;4742:6;4795:2;4783:9;4774:7;4770:23;4766:32;4763:52;;;4811:1;4808;4801:12;4763:52;-1:-1:-1;4834:23:1;;4683:180;-1:-1:-1;4683:180:1:o;4868:248::-;4936:6;4944;4997:2;4985:9;4976:7;4972:23;4968:32;4965:52;;;5013:1;5010;5003:12;4965:52;-1:-1:-1;;5036:23:1;;;5106:2;5091:18;;;5078:32;;-1:-1:-1;4868:248:1:o;5121:316::-;5162:3;5200:5;5194:12;5227:6;5222:3;5215:19;5243:63;5299:6;5292:4;5287:3;5283:14;5276:4;5269:5;5265:16;5243:63;:::i;:::-;5351:2;5339:15;5356:66;5335:88;5326:98;;;;5426:4;5322:109;;5121:316;-1:-1:-1;;5121:316:1:o;5442:470::-;5621:3;5659:6;5653:13;5675:53;5721:6;5716:3;5709:4;5701:6;5697:17;5675:53;:::i;:::-;5791:13;;5750:16;;;;5813:57;5791:13;5750:16;5847:4;5835:17;;5813:57;:::i;:::-;5886:20;;5442:470;-1:-1:-1;;;;5442:470:1:o;6358:511::-;6552:4;-1:-1:-1;;;;;6662:2:1;6654:6;6650:15;6639:9;6632:34;6714:2;6706:6;6702:15;6697:2;6686:9;6682:18;6675:43;;6754:6;6749:2;6738:9;6734:18;6727:34;6797:3;6792:2;6781:9;6777:18;6770:31;6818:45;6858:3;6847:9;6843:19;6835:6;6818:45;:::i;:::-;6810:53;6358:511;-1:-1:-1;;;;;;6358:511:1:o;7368:396::-;7511:2;7496:18;;7544:1;7533:13;;7523:201;;7580:77;7577:1;7570:88;7681:4;7678:1;7671:15;7709:4;7706:1;7699:15;7523:201;7733:25;;;7368:396;:::o;7769:219::-;7918:2;7907:9;7900:21;7881:4;7938:44;7978:2;7967:9;7963:18;7955:6;7938:44;:::i;19446:334::-;19517:2;19511:9;19573:2;19563:13;;19578:66;19559:86;19547:99;;19676:18;19661:34;;19697:22;;;19658:62;19655:88;;;19723:18;;:::i;:::-;19759:2;19752:22;19446:334;;-1:-1:-1;19446:334:1:o;19785:128::-;19825:3;19856:1;19852:6;19849:1;19846:13;19843:39;;;19862:18;;:::i;:::-;-1:-1:-1;19898:9:1;;19785:128::o;19918:120::-;19958:1;19984;19974:35;;19989:18;;:::i;:::-;-1:-1:-1;20023:9:1;;19918:120::o;20043:228::-;20083:7;20209:1;20141:66;20137:74;20134:1;20131:81;20126:1;20119:9;20112:17;20108:105;20105:131;;;20216:18;;:::i;:::-;-1:-1:-1;20256:9:1;;20043:228::o;20276:125::-;20316:4;20344:1;20341;20338:8;20335:34;;;20349:18;;:::i;:::-;-1:-1:-1;20386:9:1;;20276:125::o;20406:258::-;20478:1;20488:113;20502:6;20499:1;20496:13;20488:113;;;20578:11;;;20572:18;20559:11;;;20552:39;20524:2;20517:10;20488:113;;;20619:6;20616:1;20613:13;20610:48;;;-1:-1:-1;;20654:1:1;20636:16;;20629:27;20406:258::o;20669:437::-;20748:1;20744:12;;;;20791;;;20812:61;;20866:4;20858:6;20854:17;20844:27;;20812:61;20919:2;20911:6;20908:14;20888:18;20885:38;20882:218;;;20956:77;20953:1;20946:88;21057:4;21054:1;21047:15;21085:4;21082:1;21075:15;21111:195;21150:3;21181:66;21174:5;21171:77;21168:103;;;21251:18;;:::i;:::-;-1:-1:-1;21298:1:1;21287:13;;21111:195::o;21311:112::-;21343:1;21369;21359:35;;21374:18;;:::i;:::-;-1:-1:-1;21408:9:1;;21311:112::o;21428:184::-;21480:77;21477:1;21470:88;21577:4;21574:1;21567:15;21601:4;21598:1;21591:15;21617:184;21669:77;21666:1;21659:88;21766:4;21763:1;21756:15;21790:4;21787:1;21780:15;21806:184;21858:77;21855:1;21848:88;21955:4;21952:1;21945:15;21979:4;21976:1;21969:15;21995:184;22047:77;22044:1;22037:88;22144:4;22141:1;22134:15;22168:4;22165:1;22158:15;22184:184;22236:77;22233:1;22226:88;22333:4;22330:1;22323:15;22357:4;22354:1;22347:15;22373:184;22425:77;22422:1;22415:88;22522:4;22519:1;22512:15;22546:4;22543:1;22536:15;22562:177;22647:66;22640:5;22636:78;22629:5;22626:89;22616:117;;22729:1;22726;22719:12;22616:117;22562:177;:::o

ipfs://0a55ede0bc4a254f257d17f9b12fd89172fdd2d9fb97d1fc6777653bb1b247a2