Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/Ownable.sol";
import "base64-sol/base64.sol";
import "./StringsExtended.sol";
import "./Selection.sol";
import "./IFileStore.sol";

/// @title ExternalMetadata for Selection NFT Contract
/// @notice https://selection.folia.app
/// @author @okwme
/// @dev Updateable and replaceable metadata contract using EthFS for file storage

contract ExternalMetadata is Ownable {
    string svgOpening =
        '<?xml version="1.0" encoding="utf-8"?>'
        '<svg xmlns="http://www.w3.org/2000/svg" color="#000000" width="100%" height="100%" viewBox="0 0 300 300">'
        "<defs>"
        '<pattern id="diagonalHatch" patternUnits="userSpaceOnUse" patternTransform="translate(0)" width="8" height="8">'
        '<rect width="8" height="8" fill="white" />'
        '<path d="M-2,2 l4,-4 M0,8 l8,-8 M6,10 l4,-4" style="stroke:black; stroke-width:3"></path>'
        '<animateTransform attributeType="xml" '
        'attributeName="patternTransform" '
        'type="translate" from="0 0" to="8 8" begin="0" '
        'dur="2s" repeatCount="indefinite"/>'
        "</pattern>"
        "</defs>"
        '<text vector-effect="non-scaling-stroke" x="50%" y="55%" dominant-baseline="middle" text-anchor="middle" stroke="url(#diagonalHatch)" fill="none" style="font-size: 900%; font-family: \'Times New Roman\';">';
    string svgMiddle =
        "</text>"
        '<rect vector-effect="non-scaling-stroke" x="5%" y="5%" width="90%" height="90%" fill="none" stroke="url(#diagonalHatch)"></rect>';
    string svgClosing = "</svg>";

    string transparentPattern =
        "background-image: linear-gradient(45deg, #cbcccb 25%, transparent 25%), linear-gradient(-45deg, #cbcccb 25%, transparent 25%), linear-gradient(45deg, transparent 75%, #cbcccb 75%), linear-gradient(-45deg, transparent 75%, #cbcccb 75%);"
        "background-size: 8px 8px;"
        "background-position: 0 0, 0 4px, 4px -4px, -4px 0px;";
    address public ethfsAddress;
    address payable public selection;
    string public filename = "selection.js.gz";

    constructor(address ethfsAddress_) {
        ethfsAddress = ethfsAddress_;
    }

    function updateEthFSAddress(address ethfsAddress_) public onlyOwner {
        ethfsAddress = ethfsAddress_;
    }

    function updateSelectionAddress(
        address payable selection_
    ) public onlyOwner {
        selection = selection_;
    }

    function updateFilename(string memory filename_) public onlyOwner {
        filename = filename_;
    }

    function getBackgroundOverride(
        uint256 tokenId
    ) public view returns (bool, uint256) {
        return Selection(selection).getBackgroundOverride(tokenId);
    }

    /// @dev generates a random number between a provided range
    /// @param min the minimum value
    /// @param max the maximum value
    /// @param seed the seed
    function randomRange(
        uint256 min,
        uint256 max,
        bytes32 seed
    ) internal pure returns (uint256) {
        return (uint256(seed) % (max - min + 1)) + min;
    }

    /// @dev generates the
    /// @param tokenId the tokenId
    function getMetadata(uint256 tokenId) public view returns (string memory) {
        string memory svg = getSVG(tokenId);

        return
            string(
                abi.encodePacked(
                    "data:application/json;base64,",
                    Base64.encode(
                        abi.encodePacked(
                            '{"name":"Selection No. ',
                            getName(tokenId),
                            '",',
                            '"description": "In Selection, the focus of the work is focus itself.\\n\\n\\n',
                            "The project is a fully on-chain generated collection of selection areas, the familiar marching ants conceived by Bill Atkinson which have become such a ubiquitous part of interface culture.\\n\\n\\n",
                            "Selection is released in partnership with Folia.",
                            '","image": "',
                            svg,
                            '",',
                            '"image_url": "',
                            svg,
                            '",',
                            '"home_url": "https://selection.folia.app#',
                            StringsExtended.toString(tokenId),
                            '","external_url": "https://selection.folia.app#',
                            StringsExtended.toString(tokenId),
                            '","animation_url":"',
                            getHTML(tokenId),
                            '",',
                            '"attributes": ',
                            getAttributes(tokenId),
                            "}"
                        )
                    )
                )
            );
    }

    string htmlStart =
        '<!DOCTYPE html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>Selection, 2024 - Jan Robert Leegte</title><style>html,body{width:100vw;height:100vh}body{overflow:hidden}svg{width:100vw;height:100vh;position:absolute;inset:0}</style><meta http-equiv="X-UA-Compatible" content="IE=9">';

    string htmlClose =
        '</head><body> <svg color="#000" style="background-color:#0000"><defs><pattern patternTransform="translate(0)" id="diagonalHatch" width="8" height="8" patternUnits="userSpaceOnUse"><rect width="8" height="8" fill="#fff"/><path d="m-2 2 4-4M0 8l8-8M6 10l4-4" style="stroke:#000;stroke-width:3px"/><animateTransform type="translate" from="0 0" to="8 8" begin="0" dur="2s" attributeType="xml" attributeName="patternTransform" repeatCount="indefinite"/></pattern></defs><path id="selectionPath" d="" stroke="url(#diagonalHatch)" fill="none"/></svg> </body></html>';

    function getHTML(uint256 tokenId) public view returns (string memory) {
        IFileStore fileStore = IFileStore(ethfsAddress);
        (
            bool backgroundOverriden,
            uint256 backgroundOverride
        ) = getBackgroundOverride(tokenId);
        return
            string(
                abi.encodePacked(
                    "data:text/html;base64,",
                    Base64.encode(
                        abi.encodePacked(
                            htmlStart,
                            "<script>window.location.hash=",
                            StringsExtended.toString(tokenId),
                            ";window.backgroundOverride=",
                            backgroundOverriden
                                ? StringsExtended.toString(backgroundOverride)
                                : "false",
                            ";</script>",
                            '<script type="text/javascript+gzip" src="data:text/javascript;base64,',
                            fileStore.getFile(filename).read(),
                            '"></script>',
                            '<script src="data:text/javascript;base64,',
                            fileStore.getFile("gunzipScripts-0.0.1.js").read(),
                            '"></script>',
                            htmlClose
                        )
                    )
                )
            );
    }

    function getName(uint256 tokenId) public pure returns (string memory) {
        return string(abi.encodePacked(StringsExtended.toString(tokenId)));
    }

    /// @dev function to generate a SVG String
    function getSVG(uint256 tokenId) public view returns (string memory) {
        bytes32 originalSeed = keccak256(abi.encodePacked(tokenId));
        string[3] memory solidsArray = [
            "rgb(123,50,50)",
            "rgb(50,123,50)",
            "rgb(50,50,123)"
        ];
        uint256 solidColor = randomRange(0, 2, originalSeed);
        string memory solidColorString = string(
            abi.encodePacked("background-color:", solidsArray[solidColor])
        );
        bytes32 seed = keccak256(abi.encodePacked(originalSeed));
        bool solidOverGrad = randomRange(0, 10, seed) == 0 ? true : false;
        seed = keccak256(abi.encodePacked(seed));
        bool grayOverColor = randomRange(0, 5, seed) == 0 ? true : false;
        seed = keccak256(abi.encodePacked(seed));
        uint256 bgStyleRand = randomRange(1, 10, seed);
        (
            bool backroundOverridden,
            uint256 backgroundOverride
        ) = getBackgroundOverride(tokenId);

        // 0: color
        // 1: white
        // 2: black
        // 3: transparent
        uint256 bgStyle = backroundOverridden
            ? backgroundOverride
            : bgStyleRand <= 7
            ? 0
            : (bgStyleRand <= 8 ? 1 : (bgStyleRand <= 9 ? 2 : 3));
        string memory finalColor;
        string memory name;
        if (bgStyle == 0) {
            if (solidOverGrad) {
                name = StringsExtended.toString(solidColor);
                finalColor = solidColorString;
            } else if (grayOverColor) {
                name = "gray";
                seed = keccak256(abi.encodePacked(seed));
                uint256 gradAngle = randomRange(0, 90, seed);
                seed = keccak256(abi.encodePacked(seed));
                uint256 gray1Val = randomRange(0, 150, seed);
                string memory gray1 = string(
                    abi.encodePacked(
                        "rgb(",
                        StringsExtended.toString(gray1Val),
                        ",",
                        StringsExtended.toString(gray1Val),
                        ",",
                        StringsExtended.toString(gray1Val),
                        ")"
                    )
                );
                seed = keccak256(abi.encodePacked(seed));
                uint256 gray2Val = randomRange(150, 255, seed);
                string memory gray2 = string(
                    abi.encodePacked(
                        "rgb(",
                        StringsExtended.toString(gray2Val),
                        ",",
                        StringsExtended.toString(gray2Val),
                        ",",
                        StringsExtended.toString(gray2Val),
                        ")"
                    )
                );
                finalColor = string(
                    abi.encodePacked(
                        "background: linear-gradient(",
                        StringsExtended.toString(gradAngle),
                        "deg, ",
                        gray1,
                        " 0%, ",
                        gray2,
                        " 100%);"
                    )
                );
            } else {
                name = "color";
                seed = keccak256(abi.encodePacked(seed));
                uint256 gradAngle = randomRange(0, 90, seed);

                seed = keccak256(abi.encodePacked(seed));
                uint256 dark = randomRange(100, 150, seed);

                seed = keccak256(abi.encodePacked(seed));

                uint256 color1R = randomRange(50, dark, seed);
                seed = keccak256(abi.encodePacked(seed));
                uint256 color1G = randomRange(50, dark, seed);
                seed = keccak256(abi.encodePacked(seed));
                uint256 color1B = randomRange(50, dark, seed);

                string memory color1 = string(
                    abi.encodePacked(
                        "rgb(",
                        StringsExtended.toString(color1R),
                        ",",
                        StringsExtended.toString(color1G),
                        ",",
                        StringsExtended.toString(color1B),
                        ")"
                    )
                );

                seed = keccak256(abi.encodePacked(seed));
                bool addOrSubtract = randomRange(0, 1, seed) == 0
                    ? true
                    : false;
                seed = keccak256(abi.encodePacked(seed));
                uint256 colorOffset = randomRange(0, 100, seed);

                if (addOrSubtract) {
                    color1R = color1R + colorOffset;
                    color1R = color1R > 255 ? 255 : color1R;
                    color1G = color1G + colorOffset;
                    color1G = color1G > 255 ? 255 : color1G;
                    color1B = color1B + colorOffset;
                    color1B = color1B > 255 ? 255 : color1B;
                } else {
                    color1R = colorOffset > color1R ? 0 : color1R - colorOffset;
                    color1G = colorOffset > color1G ? 0 : color1G - colorOffset;
                    color1B = colorOffset > color1B ? 0 : color1B - colorOffset;
                }

                string memory color2 = string(
                    abi.encodePacked(
                        "rgb(",
                        StringsExtended.toString(color1R),
                        ",",
                        StringsExtended.toString(color1G),
                        ",",
                        StringsExtended.toString(color1B),
                        ")"
                    )
                );
                finalColor = string(
                    abi.encodePacked(
                        "background: linear-gradient(",
                        StringsExtended.toString(gradAngle),
                        "deg, ",
                        color1,
                        " 0%, ",
                        color2,
                        " 100%);"
                    )
                );
            }
        } else if (bgStyle == 1) {
            name = "white";
            finalColor = "background-color: white;";
        } else if (bgStyle == 2) {
            name = "black";
            finalColor = "background-color: black;";
        } else {
            name = "transparent";
            finalColor = transparentPattern;
        }

        string memory cssStart = "<style>"
        "svg {";

        string memory cssEnd = string(
            abi.encodePacked(
                "}",
                "bgStyle {",
                StringsExtended.toString(bgStyle),
                ":",
                StringsExtended.toHexString(uint256(originalSeed)),
                "}",
                "</style>"
            )
        );
        return
            string(
                abi.encodePacked(
                    "data:image/svg+xml;base64,",
                    Base64.encode(
                        abi.encodePacked(
                            svgOpening,
                            StringsExtended.toString(tokenId),
                            svgMiddle,
                            "<name>",
                            name,
                            "</name>",
                            cssStart,
                            finalColor,
                            cssEnd,
                            svgClosing
                        )
                    )
                )
            );
    }

    /// @dev generates the attributes as JSON String
    function getAttributes(
        uint256 tokenId
    ) public pure returns (string memory) {
        bytes32 seed = keccak256(abi.encodePacked(tokenId));
        bool showHole = randomRange(0, 10, seed) == 0;

        bytes32 configSeed = keccak256(abi.encodePacked(seed));
        bool showRectangles = showHole || randomRange(0, 1, configSeed) == 0;

        configSeed = keccak256(abi.encodePacked(configSeed));
        bool showPolygons = showHole ||
            !showRectangles ||
            randomRange(0, 1, configSeed) == 0;

        configSeed = keccak256(abi.encodePacked(configSeed));
        bool showGrid = randomRange(0, 3, configSeed) == 0;

        configSeed = keccak256(abi.encodePacked(configSeed));
        bool showStar = randomRange(0, 15, configSeed) == 0;

        configSeed = keccak256(abi.encodePacked(configSeed));
        bool showFrame = randomRange(0, 3, configSeed) == 0;

        // showRectangles, showPolygons, showHole, showGrid, showStar, showFrame
        return
            string(
                abi.encodePacked(
                    "[",
                    '{"trait_type":"Rectangles","value":"',
                    (showRectangles ? "Show" : "Hide"),
                    '"},',
                    '{"trait_type":"Polygon","value":"',
                    (showPolygons ? "Show" : "Hide"),
                    '"},',
                    '{"trait_type":"Hole","value":"',
                    (showHole ? "Show" : "Hide"),
                    '"},',
                    '{"trait_type":"Grid","value":"',
                    (showGrid ? "Show" : "Hide"),
                    '"},',
                    '{"trait_type":"Star","value":"',
                    (showStar ? "Show" : "Hide"),
                    '"},',
                    '{"trait_type":"Ornament","value":"',
                    (showFrame ? "Show" : "Hide"),
                    '"}',
                    "]"
                )
            );
    }
}

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

pragma solidity ^0.8.0;

import "../utils/Context.sol";

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

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

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.0;

import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./extensions/IERC721Metadata.sol";
import "../../utils/Address.sol";
import "../../utils/Context.sol";
import "../../utils/Strings.sol";
import "../../utils/introspection/ERC165.sol";

/**
 * @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: address zero is not a valid owner");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _ownerOf(tokenId);
        require(owner != address(0), "ERC721: invalid token ID");
        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) {
        _requireMinted(tokenId);

        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 overridden 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 token owner or approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        _requireMinted(tokenId);

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_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: caller is not token owner or 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: caller is not token owner or 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 the owner of the `tokenId`. Does NOT revert if token doesn't exist
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @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 _ownerOf(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) {
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == 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, 1);

        // Check that tokenId was not minted by `_beforeTokenTransfer` hook
        require(!_exists(tokenId), "ERC721: token already minted");

        unchecked {
            // Will not overflow unless all 2**256 token ids are minted to the same owner.
            // Given that tokens are minted one by one, it is impossible in practice that
            // this ever happens. Might change if we allow batch minting.
            // The ERC fails to describe this case.
            _balances[to] += 1;
        }

        _owners[tokenId] = to;

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

        _afterTokenTransfer(address(0), to, tokenId, 1);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

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

        // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
        owner = ERC721.ownerOf(tokenId);

        // Clear approvals
        delete _tokenApprovals[tokenId];

        unchecked {
            // Cannot overflow, as that would require more tokens to be burned/transferred
            // out than the owner initially received through minting and transferring in.
            _balances[owner] -= 1;
        }
        delete _owners[tokenId];

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

        _afterTokenTransfer(owner, address(0), tokenId, 1);
    }

    /**
     * @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 from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId, 1);

        // Check that tokenId was not transferred by `_beforeTokenTransfer` hook
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");

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

        unchecked {
            // `_balances[from]` cannot overflow for the same reason as described in `_burn`:
            // `from`'s balance is the number of token held, which is at least one before the current
            // transfer.
            // `_balances[to]` could overflow in the conditions described in `_mint`. That would require
            // all 2**256 token ids to be minted, which in practice is impossible.
            _balances[from] -= 1;
            _balances[to] += 1;
        }
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId, 1);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits an {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

    /**
     * @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 {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
     * - When `from` is zero, the tokens will be minted for `to`.
     * - When `to` is zero, ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}

    /**
     * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
     * - When `from` is zero, the tokens were minted for `to`.
     * - When `to` is zero, ``from``'s tokens were burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * WARNING: Anyone calling this MUST ensure that the balances remain consistent with the ownership. The invariant
     * being that for any address `a` the value returned by `balanceOf(a)` must be equal to the number of tokens such
     * that `ownerOf(tokenId)` is `a`.
     */
    // solhint-disable-next-line func-name-mixedcase
    function __unsafe_increaseBalance(address account, uint256 amount) internal {
        _balances[account] += amount;
    }
}

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

pragma solidity ^0.8.0;

import "../IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

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

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

pragma solidity ^0.8.0;

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

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

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

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

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

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

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

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must 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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

pragma solidity ^0.8.1;

/**
 * @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
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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://consensys.net/diligence/blog/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.8.0/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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

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

pragma solidity ^0.8.0;

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

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

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

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

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

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

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

pragma solidity ^0.8.0;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

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

pragma solidity ^0.8.0;

import "./math/Math.sol";
import "./math/SignedMath.sol";

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @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] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

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

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0;

/// @title Base64
/// @author Brecht Devos - <[email protected]>
/// @notice Provides functions for encoding/decoding base64
library Base64 {
    string internal constant TABLE_ENCODE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
    bytes  internal constant TABLE_DECODE = hex"0000000000000000000000000000000000000000000000000000000000000000"
                                            hex"00000000000000000000003e0000003f3435363738393a3b3c3d000000000000"
                                            hex"00000102030405060708090a0b0c0d0e0f101112131415161718190000000000"
                                            hex"001a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132330000000000";

    function encode(bytes memory data) internal pure returns (string memory) {
        if (data.length == 0) return '';

        // load the table into memory
        string memory table = TABLE_ENCODE;

        // multiply by 4/3 rounded up
        uint256 encodedLen = 4 * ((data.length + 2) / 3);

        // add some extra buffer at the end required for the writing
        string memory result = new string(encodedLen + 32);

        assembly {
            // set the actual output length
            mstore(result, encodedLen)

            // prepare the lookup table
            let tablePtr := add(table, 1)

            // input ptr
            let dataPtr := data
            let endPtr := add(dataPtr, mload(data))

            // result ptr, jump over length
            let resultPtr := add(result, 32)

            // run over the input, 3 bytes at a time
            for {} lt(dataPtr, endPtr) {}
            {
                // read 3 bytes
                dataPtr := add(dataPtr, 3)
                let input := mload(dataPtr)

                // write 4 characters
                mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F))))
                resultPtr := add(resultPtr, 1)
                mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F))))
                resultPtr := add(resultPtr, 1)
                mstore8(resultPtr, mload(add(tablePtr, and(shr( 6, input), 0x3F))))
                resultPtr := add(resultPtr, 1)
                mstore8(resultPtr, mload(add(tablePtr, and(        input,  0x3F))))
                resultPtr := add(resultPtr, 1)
            }

            // padding with '='
            switch mod(mload(data), 3)
            case 1 { mstore(sub(resultPtr, 2), shl(240, 0x3d3d)) }
            case 2 { mstore(sub(resultPtr, 1), shl(248, 0x3d)) }
        }

        return result;
    }

    function decode(string memory _data) internal pure returns (bytes memory) {
        bytes memory data = bytes(_data);

        if (data.length == 0) return new bytes(0);
        require(data.length % 4 == 0, "invalid base64 decoder input");

        // load the table into memory
        bytes memory table = TABLE_DECODE;

        // every 4 characters represent 3 bytes
        uint256 decodedLen = (data.length / 4) * 3;

        // add some extra buffer at the end required for the writing
        bytes memory result = new bytes(decodedLen + 32);

        assembly {
            // padding with '='
            let lastBytes := mload(add(data, mload(data)))
            if eq(and(lastBytes, 0xFF), 0x3d) {
                decodedLen := sub(decodedLen, 1)
                if eq(and(lastBytes, 0xFFFF), 0x3d3d) {
                    decodedLen := sub(decodedLen, 1)
                }
            }

            // set the actual output length
            mstore(result, decodedLen)

            // prepare the lookup table
            let tablePtr := add(table, 1)

            // input ptr
            let dataPtr := data
            let endPtr := add(dataPtr, mload(data))

            // result ptr, jump over length
            let resultPtr := add(result, 32)

            // run over the input, 4 characters at a time
            for {} lt(dataPtr, endPtr) {}
            {
               // read 4 characters
               dataPtr := add(dataPtr, 4)
               let input := mload(dataPtr)

               // write 3 bytes
               let output := add(
                   add(
                       shl(18, and(mload(add(tablePtr, and(shr(24, input), 0xFF))), 0xFF)),
                       shl(12, and(mload(add(tablePtr, and(shr(16, input), 0xFF))), 0xFF))),
                   add(
                       shl( 6, and(mload(add(tablePtr, and(shr( 8, input), 0xFF))), 0xFF)),
                               and(mload(add(tablePtr, and(        input , 0xFF))), 0xFF)
                    )
                )
                mstore(resultPtr, shl(232, output))
                resultPtr := add(resultPtr, 3)
            }
        }

        return result;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.22;

/**
 * @title EthFS File
 * @notice A representation of an onchain file, composed of slices of contract bytecode and utilities to construct the file contents from those slices.
 * @dev For best gas efficiency, it's recommended using `File.read()` as close to the output returned by the contract call as possible. Lots of gas is consumed every time a large data blob is passed between functions.
 */

/**
 * @dev Represents a reference to a slice of bytecode in a contract
 */
struct BytecodeSlice {
    address pointer;
    uint32 start;
    uint32 end;
}

/**
 * @dev Represents a file composed of one or more bytecode slices
 */
struct File {
    // Total length of file contents (sum of all slice sizes). Useful when you want to use DynamicBuffer to build the file contents from the slices.
    uint256 size;
    BytecodeSlice[] slices;
}
// extend File struct with read functions
using {read} for File global;
using {readUnchecked} for File global;

/**
 * @dev Error thrown when a slice is out of the bounds of the contract's bytecode
 */
error SliceOutOfBounds(
    address pointer,
    uint32 codeSize,
    uint32 sliceStart,
    uint32 sliceEnd
);

/**
 * @notice Reads the contents of a file by concatenating its slices
 * @param file The file to read
 * @return contents The concatenated contents of the file
 */
function read(File memory file) view returns (string memory contents) {
    BytecodeSlice[] memory slices = file.slices;
    bytes4 sliceOutOfBoundsSelector = SliceOutOfBounds.selector;

    assembly {
        let len := mload(slices)
        let size := 0x20
        contents := mload(0x40)
        let slice
        let pointer
        let start
        let end
        let codeSize

        for {
            let i := 0
        } lt(i, len) {
            i := add(i, 1)
        } {
            slice := mload(add(slices, add(0x20, mul(i, 0x20))))
            pointer := mload(slice)
            start := mload(add(slice, 0x20))
            end := mload(add(slice, 0x40))

            codeSize := extcodesize(pointer)
            if gt(end, codeSize) {
                mstore(0x00, sliceOutOfBoundsSelector)
                mstore(0x04, pointer)
                mstore(0x24, codeSize)
                mstore(0x44, start)
                mstore(0x64, end)
                revert(0x00, 0x84)
            }

            extcodecopy(pointer, add(contents, size), start, sub(end, start))
            size := add(size, sub(end, start))
        }

        // update contents size
        mstore(contents, sub(size, 0x20))
        // store contents
        mstore(0x40, add(contents, and(add(size, 0x1f), not(0x1f))))
    }
}

/**
 * @notice Reads the contents of a file without reverting on unreadable/invalid slices. Skips any slices that are out of bounds or invalid. Useful if you are composing contract bytecode where a contract can still selfdestruct (which would result in an invalid slice) and want to avoid reverts but still output potentially "corrupted" file contents (due to missing data).
 * @param file The file to read
 * @return contents The concatenated contents of the file, skipping invalid slices
 */
function readUnchecked(File memory file) view returns (string memory contents) {
    BytecodeSlice[] memory slices = file.slices;

    assembly {
        let len := mload(slices)
        let size := 0x20
        contents := mload(0x40)
        let slice
        let pointer
        let start
        let end
        let codeSize

        for {
            let i := 0
        } lt(i, len) {
            i := add(i, 1)
        } {
            slice := mload(add(slices, add(0x20, mul(i, 0x20))))
            pointer := mload(slice)
            start := mload(add(slice, 0x20))
            end := mload(add(slice, 0x40))

            codeSize := extcodesize(pointer)
            if lt(end, codeSize) {
                extcodecopy(
                    pointer,
                    add(contents, size),
                    start,
                    sub(end, start)
                )
                size := add(size, sub(end, start))
            }
        }

        // update contents size
        mstore(contents, sub(size, 0x20))
        // store contents
        mstore(0x40, add(contents, and(add(size, 0x1f), not(0x1f))))
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.22;

import {File, BytecodeSlice} from "./File.sol";

/// @title EthFS FileStore interface
/// @notice Specifies a content-addressable onchain file store
interface IFileStore {
    /**
     * @notice Retrieves a file by its filename
     * @param filename The name of the file
     * @return file The file associated with the filename
     */
    function getFile(
        string memory filename
    ) external view returns (File memory file);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./ExternalMetadata.sol";

/*
- - - - - - - - - - - - - - - - - -
|                                 |

|                                 |

|                                 |

| - - - - - - - - - - - - - - - - |


Selection, 2024
Jan Robert Leegte
https://www.leegte.org
Released in partnership with Folia.

"A NFT collection where focus of the work is focus itself."
*/

/// @title Selection NFT Contract
/// @notice https://selection.folia.app
/// @author @okwme
/// @dev ERC721 contract for Selection by Jan Robert Leegte with external metadata

contract Selection is Ownable, ERC721 {
    bool public paused = false;
    uint256 public totalSupply = 0;
    uint256 public constant MAX_SUPPLY = 150;
    uint256 public priceToMint = 0.11 ether;
    uint256 public startingDate = 1726164000; // Thu Sep 12 2024 18:00:00 GMT+0000
    address payable public proceedRecipient;
    address public externalMetadata;

    mapping(uint256 => uint256) public backgroundOverride;
    mapping(uint256 => bool) public backgroundOverriden;

    constructor(address externalMetadata_) ERC721("Selection", "SEL") {
        updateExternalMetadata(externalMetadata_);
        updateProceedRecipient(payable(msg.sender));
    }

    receive() external payable {
        revert("no receive thank you");
    }

    fallback() external {
        revert("no fallback thank you");
    }

    event MetadataUpdate(uint256 _tokenId);
    event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);

    event EthMoved(
        address indexed to,
        bool indexed success,
        bytes returnData,
        uint256 amount
    );

    event BackgroundUpdated(uint256 indexed tokenId, uint256 override_);

    // public write functions

    function mint(uint256 total) public payable {
        require(total <= 5, "Max 5 per transaction");
        require(totalSupply + total <= MAX_SUPPLY, "Max supply reached");
        require(block.timestamp >= startingDate, "not yet started");
        require(!paused, "paused");
        for (uint256 i = 0; i < total; i++) {
            totalSupply += 1;
            _mint(msg.sender, totalSupply);
        }
        makePayment(priceToMint * total);
    }

    function mint() public payable {
        require(totalSupply + 1 <= MAX_SUPPLY, "Max supply reached");
        require(block.timestamp >= startingDate, "not yet started");
        require(!paused, "paused");
        totalSupply += 1;
        _mint(msg.sender, totalSupply);
        makePayment(priceToMint);
    }

    function changeBackground(uint256 tokenId, uint256 override_) public {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "Not approved");
        require(override_ <= 3, "invalid override number");
        backgroundOverride[tokenId] = override_;
        backgroundOverriden[tokenId] = true;
        emit BackgroundUpdated(tokenId, override_);
        emit MetadataUpdate(tokenId);
    }

    // public read functions

    function getBackgroundOverride(
        uint256 tokenId
    ) public view returns (bool, uint256) {
        return (backgroundOverriden[tokenId], backgroundOverride[tokenId]);
    }

    function supportsInterface(
        bytes4 interfaceId
    ) public view override(ERC721) returns (bool) {
        return
            interfaceId == type(IERC165).interfaceId ||
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            interfaceId == bytes4(0x49064906) || // IERC4906 MetadataUpdate
            super.supportsInterface(interfaceId);
    }

    function tokenURI(uint256 id) public view override returns (string memory) {
        return ExternalMetadata(externalMetadata).getMetadata(id);
    }

    // public owner functions

    function adminMint(address recipient, uint256 total) public onlyOwner {
        require(totalSupply + total <= MAX_SUPPLY, "Max supply reached");
        for (uint256 i = 0; i < total; i++) {
            totalSupply += 1;
            _mint(recipient, totalSupply);
        }
    }

    function emitBatchMetadataUpdate(
        uint256 fromTokenId,
        uint256 toTokenId
    ) public onlyOwner {
        emit BatchMetadataUpdate(fromTokenId, toTokenId);
    }

    function updateExternalMetadata(
        address externalMetadata_
    ) public onlyOwner {
        externalMetadata = externalMetadata_;
    }

    /// @dev if mint fails to send eth to splitter, admin can recover
    // This should not be necessary but Berlin hardfork broke split before so this
    // is extra precaution.
    function recoverUnsuccessfulPayment(address payable _to) public onlyOwner {
        uint256 amount = address(this).balance;
        (bool sent, bytes memory data) = _to.call{value: amount}("");
        emit EthMoved(_to, sent, data, amount);
    }

    function updatePriceToMint(uint256 priceToMint_) public onlyOwner {
        priceToMint = priceToMint_;
    }

    function updateProceedRecipient(
        address payable proceedRecipient_
    ) public onlyOwner {
        proceedRecipient = proceedRecipient_;
    }

    function updateStartingDate(uint256 startingDate_) public onlyOwner {
        startingDate = startingDate_;
    }

    function updatePaused(bool paused_) public onlyOwner {
        paused = paused_;
    }

    // internal functions

    function makePayment(uint256 payment) internal {
        require(msg.value == payment, "Incorrect payment");
        require(proceedRecipient != address(0), "Invalid recipient");
        (bool sent, bytes memory data) = proceedRecipient.call{value: payment}(
            ""
        );
        emit EthMoved(proceedRecipient, sent, data, payment);
    }
}

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

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/math/SignedMath.sol";
import "hardhat/console.sol";

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return
            string(
                abi.encodePacked(
                    value < 0 ? "-" : "",
                    toString(SignedMath.abs(value))
                )
            );
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexStringWithPrefix(
        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] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @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);
        for (int256 i = 2 * int256(length) - 1; i >= 0; --i) {
            buffer[uint256(i)] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

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

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(
        string memory a,
        string memory b
    ) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;

library console {
    address constant CONSOLE_ADDRESS =
        0x000000000000000000636F6e736F6c652e6c6f67;

    function _sendLogPayloadImplementation(bytes memory payload) internal view {
        address consoleAddress = CONSOLE_ADDRESS;
        /// @solidity memory-safe-assembly
        assembly {
            pop(
                staticcall(
                    gas(),
                    consoleAddress,
                    add(payload, 32),
                    mload(payload),
                    0,
                    0
                )
            )
        }
    }

    function _castToPure(
      function(bytes memory) internal view fnIn
    ) internal pure returns (function(bytes memory) pure fnOut) {
        assembly {
            fnOut := fnIn
        }
    }

    function _sendLogPayload(bytes memory payload) internal pure {
        _castToPure(_sendLogPayloadImplementation)(payload);
    }

    function log() internal pure {
        _sendLogPayload(abi.encodeWithSignature("log()"));
    }
    function logInt(int256 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(int256)", p0));
    }

    function logUint(uint256 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
    }

    function logString(string memory p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
    }

    function logBool(bool p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
    }

    function logAddress(address p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
    }

    function logBytes(bytes memory p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
    }

    function logBytes1(bytes1 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
    }

    function logBytes2(bytes2 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
    }

    function logBytes3(bytes3 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
    }

    function logBytes4(bytes4 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
    }

    function logBytes5(bytes5 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
    }

    function logBytes6(bytes6 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
    }

    function logBytes7(bytes7 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
    }

    function logBytes8(bytes8 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
    }

    function logBytes9(bytes9 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
    }

    function logBytes10(bytes10 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
    }

    function logBytes11(bytes11 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
    }

    function logBytes12(bytes12 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
    }

    function logBytes13(bytes13 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
    }

    function logBytes14(bytes14 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
    }

    function logBytes15(bytes15 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
    }

    function logBytes16(bytes16 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
    }

    function logBytes17(bytes17 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
    }

    function logBytes18(bytes18 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
    }

    function logBytes19(bytes19 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
    }

    function logBytes20(bytes20 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
    }

    function logBytes21(bytes21 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
    }

    function logBytes22(bytes22 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
    }

    function logBytes23(bytes23 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
    }

    function logBytes24(bytes24 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
    }

    function logBytes25(bytes25 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
    }

    function logBytes26(bytes26 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
    }

    function logBytes27(bytes27 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
    }

    function logBytes28(bytes28 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
    }

    function logBytes29(bytes29 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
    }

    function logBytes30(bytes30 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
    }

    function logBytes31(bytes31 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
    }

    function logBytes32(bytes32 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
    }

    function log(uint256 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
    }

    function log(string memory p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
    }

    function log(bool p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
    }

    function log(address p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
    }

    function log(uint256 p0, uint256 p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256)", p0, p1));
    }

    function log(uint256 p0, string memory p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string)", p0, p1));
    }

    function log(uint256 p0, bool p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool)", p0, p1));
    }

    function log(uint256 p0, address p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address)", p0, p1));
    }

    function log(string memory p0, uint256 p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
    }

    function log(string memory p0, string memory p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
    }

    function log(string memory p0, bool p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
    }

    function log(string memory p0, address p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
    }

    function log(bool p0, uint256 p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256)", p0, p1));
    }

    function log(bool p0, string memory p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
    }

    function log(bool p0, bool p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
    }

    function log(bool p0, address p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
    }

    function log(address p0, uint256 p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256)", p0, p1));
    }

    function log(address p0, string memory p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
    }

    function log(address p0, bool p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
    }

    function log(address p0, address p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
    }

    function log(uint256 p0, uint256 p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256)", p0, p1, p2));
    }

    function log(uint256 p0, uint256 p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string)", p0, p1, p2));
    }

    function log(uint256 p0, uint256 p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool)", p0, p1, p2));
    }

    function log(uint256 p0, uint256 p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address)", p0, p1, p2));
    }

    function log(uint256 p0, string memory p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256)", p0, p1, p2));
    }

    function log(uint256 p0, string memory p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string)", p0, p1, p2));
    }

    function log(uint256 p0, string memory p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool)", p0, p1, p2));
    }

    function log(uint256 p0, string memory p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address)", p0, p1, p2));
    }

    function log(uint256 p0, bool p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256)", p0, p1, p2));
    }

    function log(uint256 p0, bool p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string)", p0, p1, p2));
    }

    function log(uint256 p0, bool p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool)", p0, p1, p2));
    }

    function log(uint256 p0, bool p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address)", p0, p1, p2));
    }

    function log(uint256 p0, address p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256)", p0, p1, p2));
    }

    function log(uint256 p0, address p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string)", p0, p1, p2));
    }

    function log(uint256 p0, address p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool)", p0, p1, p2));
    }

    function log(uint256 p0, address p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address)", p0, p1, p2));
    }

    function log(string memory p0, uint256 p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256)", p0, p1, p2));
    }

    function log(string memory p0, uint256 p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string)", p0, p1, p2));
    }

    function log(string memory p0, uint256 p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool)", p0, p1, p2));
    }

    function log(string memory p0, uint256 p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address)", p0, p1, p2));
    }

    function log(string memory p0, string memory p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256)", p0, p1, p2));
    }

    function log(string memory p0, string memory p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
    }

    function log(string memory p0, string memory p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
    }

    function log(string memory p0, string memory p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
    }

    function log(string memory p0, bool p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256)", p0, p1, p2));
    }

    function log(string memory p0, bool p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
    }

    function log(string memory p0, bool p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
    }

    function log(string memory p0, bool p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
    }

    function log(string memory p0, address p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256)", p0, p1, p2));
    }

    function log(string memory p0, address p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
    }

    function log(string memory p0, address p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
    }

    function log(string memory p0, address p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
    }

    function log(bool p0, uint256 p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256)", p0, p1, p2));
    }

    function log(bool p0, uint256 p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string)", p0, p1, p2));
    }

    function log(bool p0, uint256 p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool)", p0, p1, p2));
    }

    function log(bool p0, uint256 p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address)", p0, p1, p2));
    }

    function log(bool p0, string memory p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256)", p0, p1, p2));
    }

    function log(bool p0, string memory p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
    }

    function log(bool p0, string memory p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
    }

    function log(bool p0, string memory p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
    }

    function log(bool p0, bool p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256)", p0, p1, p2));
    }

    function log(bool p0, bool p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
    }

    function log(bool p0, bool p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
    }

    function log(bool p0, bool p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
    }

    function log(bool p0, address p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256)", p0, p1, p2));
    }

    function log(bool p0, address p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
    }

    function log(bool p0, address p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
    }

    function log(bool p0, address p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
    }

    function log(address p0, uint256 p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256)", p0, p1, p2));
    }

    function log(address p0, uint256 p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string)", p0, p1, p2));
    }

    function log(address p0, uint256 p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool)", p0, p1, p2));
    }

    function log(address p0, uint256 p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address)", p0, p1, p2));
    }

    function log(address p0, string memory p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256)", p0, p1, p2));
    }

    function log(address p0, string memory p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
    }

    function log(address p0, string memory p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
    }

    function log(address p0, string memory p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
    }

    function log(address p0, bool p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256)", p0, p1, p2));
    }

    function log(address p0, bool p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
    }

    function log(address p0, bool p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
    }

    function log(address p0, bool p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
    }

    function log(address p0, address p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256)", p0, p1, p2));
    }

    function log(address p0, address p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
    }

    function log(address p0, address p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
    }

    function log(address p0, address p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
    }

    function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,string)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,address)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,string)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,address)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,string)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,address)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,string)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,address)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,string)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,address)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,string)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,address)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,string)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,address)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,string)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,bool)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,address)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,string)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,bool)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,address)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,string)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,bool)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,address)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,string)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,bool)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,address)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,string)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,bool)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,address)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,string)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,bool)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,address)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,string)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,bool)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,address)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
    }

}

{
  "viaIR": true,
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"ethfsAddress_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"ethfsAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"filename","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getAttributes","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getBackgroundOverride","outputs":[{"internalType":"bool","name":"","type":"bool"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getHTML","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getMetadata","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getSVG","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"selection","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"ethfsAddress_","type":"address"}],"name":"updateEthFSAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"filename_","type":"string"}],"name":"updateFilename","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"selection_","type":"address"}],"name":"updateSelectionAddress","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60803462000cef57601f90620035fe38819003838101601f191683016001600160401b0381118482101762000cf45783928291604052833960209283918101031262000cef57516001600160a01b0380821692909183900362000cef57600093845460018060a01b031993338583161787553391167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e08780a3600191620000a7835462000d0a565b82811162000cbf575b50906017916105f98455838752808720907f3c3f786d6c2076657273696f6e3d22312e302220656e636f64696e673d22757482557f662d38223f3e3c73766720786d6c6e733d22687474703a2f2f7777772e77332e8583015560027f6f72672f323030302f7376672220636f6c6f723d222330303030303022207769818401556003907f6474683d223130302522206865696768743d2231303025222076696577426f78828501556004927f3d223020302033303020333030223e3c646566733e3c7061747465726e2069648486015560059a8b967f3d22646961676f6e616c486174636822207061747465726e556e6974733d2275888801557f73657253706163654f6e55736522207061747465726e5472616e73666f726d3d6006880155896007977f227472616e736c617465283029222077696474683d223822206865696768743d898201556008997f2238223e3c726563742077696474683d223822206865696768743d22382220668b8301557f66616d696c793a202754696d6573204e657720526f6d616e273b223e0000000060099c837f696c6c3d22776869746522202f3e3c7061746820643d224d2d322c32206c342c8f809601557f2d34204d302c38206c382c2d38204d362c3130206c342c2d3422207374796c65600a8201557f3d227374726f6b653a626c61636b3b207374726f6b652d77696474683a33223e600b8201557f3c2f706174683e3c616e696d6174655472616e73666f726d2061747472696275600c8201557f7465547970653d22786d6c22206174747269627574654e616d653d2270617474600d8201557f65726e5472616e73666f726d2220747970653d227472616e736c617465222066600e8201557f726f6d3d223020302220746f3d223820382220626567696e3d22302220647572600f8201557f3d2232732220726570656174436f756e743d22696e646566696e697465222f3e60108201557f3c2f7061747465726e3e3c2f646566733e3c7465787420766563746f722d656660118201557f666563743d226e6f6e2d7363616c696e672d7374726f6b652220783d2235302560128201557f2220793d223535252220646f6d696e616e742d626173656c696e653d226d696460138201557f646c652220746578742d616e63686f723d226d6964646c6522207374726f6b6560148201557f3d2275726c2823646961676f6e616c486174636829222066696c6c3d226e6f6e60158201557f6522207374796c653d22666f6e742d73697a653a20393030253b20666f6e742d6016820155015562000468875462000d0a565b84811162000c8a575b5061010f8755868552661e17b932b1ba1f60c91b898787207f3c2f746578743e3c7265637420766563746f722d6566666563743d226e6f6e2d81557f7363616c696e672d7374726f6b652220783d2235252220793d22352522207769868201557f6474683d2239302522206865696768743d22393025222066696c6c3d226e6f6e8a8201557f6522207374726f6b653d2275726c2823646961676f6e616c486174636829223e8b820155015562000529885462000d0a565b84811162000c57575b50600c651e17b9bb339f60d11b01885588546200054f9062000d0a565b84811162000c1b575b50917f74203735252c202363626363636220373525292c206c696e6561722d677261647f3470782c20347078202d3470782c202d347078203070783b0000000000000000936102718b558a87527f742834356465672c2023636263636362203235252c207472616e73706172656e888820937f6261636b67726f756e642d696d6167653a206c696e6561722d6772616469656e85558401557f7420323525292c206c696e6561722d6772616469656e74282d34356465672c20898401557f23636263636362203235252c207472616e73706172656e7420323525292c206c8a8401557f696e6561722d6772616469656e742834356465672c207472616e73706172656e8b8401558201557f69656e74282d34356465672c207472616e73706172656e74203735252c20236360068201557f626363636220373525293b6261636b67726f756e642d73697a653a20387078208a8201557f3870783b6261636b67726f756e642d706f736974696f6e3a203020302c2030208b8201550155620006e0875462000d0a565b81811162000bee575b50601e6e39b2b632b1ba34b7b71735399733bd60891b018755898d620007108a5462000d0a565b83811162000bb6575b507f617469626c652220636f6e74656e743d2249453d39223e000000000000000000917f2f7469746c653e3c7374796c653e68746d6c2c626f64797b77696474683a3130600a926102af8d558c87527f20636861727365743d227574662d38223e3c6d657461206e616d653d22766965888820937f3c21444f43545950452068746d6c3e3c68746d6c3e3c686561643e3c6d65746185558401557f77706f72742220636f6e74656e743d2277696474683d6465766963652d776964898401557f74682c20696e697469616c2d7363616c653d31223e3c7469746c653e53656c658a8401557f6374696f6e2c2032303234202d204a616e20526f62657274204c65656774653c8b8401558201557f3076773b6865696768743a31303076687d626f64797b6f766572666c6f773a6860068201557f696464656e7d7376677b77696474683a31303076773b6865696768743a3130308a8201557f76683b706f736974696f6e3a6162736f6c7574653b696e7365743a307d3c2f738b8201557f74796c653e3c6d65746120687474702d65717569763d22582d55412d436f6d708c82015501558c620008c98a5462000d0a565b9180831162000b8a575b505050947f2077696474683d223822206865696768743d223822207061747465726e556e6988957f7472616e736c617465283029222069643d22646961676f6e616c4861746368227f207374796c653d227374726f6b653a233030303b7374726f6b652d7769647468967f646566733e3c7061747465726e207061747465726e5472616e73666f726d3d226d1e17b137b23c9f1e17b43a36b61f60911b9d9b977f7374796c653d226261636b67726f756e642d636f6c6f723a2330303030223e3c7f6820643d226d2d32203220342d344d3020386c382d384d362031306c342d34229860119f9d61045d7f3a337078222f3e3c616e696d6174655472616e73666f726d20747970653d22749f558d8152209d8e7f3c2f686561643e3c626f64793e203c73766720636f6c6f723d22233030302220815501558c01558a01558801557f74733d227573657253706163654f6e557365223e3c726563742077696474683d8c8801557f223822206865696768743d2238222066696c6c3d2223666666222f3e3c70617460068801558601558401558201557f72616e736c617465222066726f6d3d223020302220746f3d2238203822206265600a8201557f67696e3d223022206475723d2232732220617474726962757465547970653d22600b8201557f786d6c22206174747269627574654e616d653d227061747465726e5472616e73600c8201557f666f726d2220726570656174436f756e743d22696e646566696e697465222f3e600d8201557f3c2f7061747465726e3e3c2f646566733e3c706174682069643d2273656c6563600e8201557f74696f6e506174682220643d2222207374726f6b653d2275726c282364696167600f8201557f6f6e616c486174636829222066696c6c3d226e6f6e65222f3e3c2f7376673e20601082015501558254161790556040516128b6908162000d488239f35b8a84528484209201901c8101906012015b81811062000bab578d90620008d3565b8281558a0162000b9b565b8a8593929352600b848787209201841c820191015b81811062000bdd575091909162000719565b909250848155018e918c9162000bcb565b8a8e898552838686209301901c8201915b82811062000c0f575050620006e9565b848155018b9062000bff565b898694929452600a858888209201851c820191015b81811062000c42575092909262000558565b869194508092935055018b8f928c9262000c30565b888652848787209101821c8101905b81811062000c75575062000532565b869194935080925055018e8c928c9262000c66565b87865281858888209201811c820191015b81811062000caa575062000471565b869194935080925055018e8c928c9262000c9b565b83875283601884848a20930160051c830192015b82811062000ce3575050620000b0565b88815501849062000cd3565b600080fd5b634e487b7160e01b600052604160045260246000fd5b90600182811c9216801562000d3c575b602083101462000d2657565b634e487b7160e01b600052602260045260246000fd5b91607f169162000d1a56fe6080604052600436101561001257600080fd5b60003560e01c8063102581d21461010757806315c63984146101025780633c356268146100fd5780634378a6e3146100f85780636b8ff574146100f3578063715018a6146100ee5780638526d3b9146100e957806388f29078146100e45780638da5cb5b146100df578063a2932558146100da578063a574cea4146100d5578063b6482aad146100d0578063be985ac9146100cb578063f0099a75146100c65763f2fde38b146100c157600080fd5b610a25565b6109b0565b61096e565b610927565b61055d565b610499565b6102fb565b6102d5565b61028e565b61021f565b610206565b6101ed565b6101c4565b61019b565b610172565b602090600319011261011e5760043590565b600080fd5b60005b8381106101365750506000910152565b8181015183820152602001610126565b604091602082526101668151809281602086015260208686019101610123565b601f01601f1916010190565b3461011e5761019761018b6101863661010c565b610f81565b60405191829182610146565b0390f35b3461011e57600036600319011261011e576006546040516001600160a01b039091168152602090f35b3461011e57600036600319011261011e576005546040516001600160a01b039091168152602090f35b3461011e5761019761018b6102013661010c565b61129b565b3461011e5761019761018b61021a3661010c565b61161a565b3461011e5760008060031936011261027a5761023961264a565b80546001600160a01b03198116825581906001600160a01b03167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e08280a380f35b80fd5b6001600160a01b0381160361011e57565b3461011e57602036600319011261011e576004356102ab8161027d565b6102b361264a565b600680546001600160a01b0319166001600160a01b0392909216919091179055005b3461011e5760406102ed6102e83661010c565b61164c565b825191151582526020820152f35b3461011e57600036600319011261011e576000546040516001600160a01b039091168152602090f35b90600182811c92168015610354575b602083101461033e57565b634e487b7160e01b600052602260045260246000fd5b91607f1691610333565b634e487b7160e01b600052604160045260246000fd5b6040810190811067ffffffffffffffff82111761039057604052565b61035e565b6060810190811067ffffffffffffffff82111761039057604052565b90601f8019910116810190811067ffffffffffffffff82111761039057604052565b60405190600082600454916103e783610324565b808352926020906001908181169081156104755750600114610414575b5050610412925003836103b1565b565b91509260046000527f8a35acfbc15ff81a39ae7d344fd709f28e8600b4aa8c65c6b64bfe7fe36bd19b936000925b82841061045d57506104129450505081016020013880610404565b85548885018301529485019487945092810192610442565b9150506020925061041294915060ff191682840152151560051b8201013880610404565b3461011e5760008060031936011261027a576040519080600754906104bd82610324565b8085529160209160019182811690811561053057506001146104ea575b6101978661018b818803826103b1565b9350600784526000805160206128618339815191525b83851061051d5750505050810160200161018b82610197386104da565b8054868601840152938201938101610500565b90508695506101979693506020925061018b94915060ff191682840152151560051b8201019293386104da565b3461011e5761056b3661010c565b61057481611919565b9061057e8161161a565b9061058881612296565b9061059281612296565b61059b82610f81565b916105a59061129b565b6040517f7b226e616d65223a2253656c656374696f6e204e6f2e200000000000000000006020820152958695919491603787016105e191610f6a565b61088b60f21b81526002017f226465736372697074696f6e223a2022496e2053656c656374696f6e2c20746881527f6520666f637573206f662074686520776f726b20697320666f6375732069747360208201526932b633172e372e372e3760b11b6040820152604a017f5468652070726f6a65637420697320612066756c6c79206f6e2d636861696e2081527f67656e65726174656420636f6c6c656374696f6e206f662073656c656374696f60208201527f6e2061726561732c207468652066616d696c696172206d61726368696e67206160408201527f6e747320636f6e6365697665642062792042696c6c2041746b696e736f6e207760608201527f686963682068617665206265636f6d652073756368206120756269717569746f60808201527f75732070617274206f6620696e746572666163652063756c747572652e5c6e5c60a082015262372e3760e91b60c082015260c3017f53656c656374696f6e2069732072656c656173656420696e20706172746e657281526f39b434b8103bb4ba34102337b634b09760811b60208201526030016b11161134b6b0b3b2911d101160a11b8152600c016107999082610f6a565b61088b60f21b81526002016d1134b6b0b3b2afbab936111d101160911b8152600e016107c491610f6a565b61088b60f21b81526002017f22686f6d655f75726c223a202268747470733a2f2f73656c656374696f6e2e668152686f6c69612e6170702360b81b602082015260290161081091610f6a565b7f222c2265787465726e616c5f75726c223a202268747470733a2f2f73656c656381526e74696f6e2e666f6c69612e6170702360881b6020820152602f0161085791610f6a565b7211161130b734b6b0ba34b7b72fbab936111d1160691b815260130161087c91610f6a565b61088b60f21b81526002016d01130ba3a3934b13aba32b9911d160951b8152600e016108a791610f6a565b607d60f81b81526001010390601f199182810182526108c690826103b1565b6108cf906124e7565b6040517f646174613a6170706c69636174696f6e2f6a736f6e3b6261736536342c000000602082015291908290603d820161090991610f6a565b03908101825261091990826103b1565b604051610197819282610146565b3461011e57602036600319011261011e576004356109448161027d565b61094c61264a565b600580546001600160a01b0319166001600160a01b0392909216919091179055005b3461011e5761019761018b6109823661010c565b611919565b6040519061041282610395565b67ffffffffffffffff811161039057601f01601f191660200190565b3461011e57602036600319011261011e5760043567ffffffffffffffff811161011e573660238201121561011e5780600401356109ec81610994565b906109fa60405192836103b1565b808252366024828501011161011e576020816000926024610a239601838601378301015261211d565b005b3461011e57602036600319011261011e57600435610a428161027d565b610a4a61264a565b6001600160a01b039081168015610a9857600080546001600160a01b03198116831782559092167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e08380a380f35b60405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608490fd5b604051906020820182811067ffffffffffffffff8211176103905760405260008252565b60405190610b1d82610374565b600582526466616c736560d81b6020830152565b519063ffffffff8216820361011e57565b906020808383031261011e57825167ffffffffffffffff9384821161011e570192604092838582031261011e57835194610b7b86610374565b80518652838101519083821161011e57019080601f8301121561011e57815192831161039057845194610bb3858560051b01876103b1565b838652848601918560608096028501019381851161011e578601925b848410610be25750505050505082015290565b858483031261011e578686918451610bf981610395565b8651610c048161027d565b8152610c11838801610b31565b83820152610c20868801610b31565b86820152815201930192610bcf565b6020808252600754600092610c4382610324565b918260208301526040600191600181169081600014610cba5750600114610c6d575b505050505090565b60076000908152949695509192916000805160206128618339815191525b838610610ca75750505050604092935001013880808080610c65565b8054858701830152948701948201610c8b565b9395505050506040935060ff191683830152151560051b01013880808080610c65565b6040513d6000823e3d90fd5b60085460009291610cf982610324565b91600190818116908115610d655750600114610d1457505050565b909192935060086000527ff3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee3906000915b848310610d52575050500190565b8181602092548587015201920191610d44565b60ff191683525050811515909102019150565b60095460009291610d8882610324565b91600190818116908115610d655750600114610da357505050565b909192935060096000527f6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7af906000915b848310610de1575050500190565b8181602092548587015201920191610dd3565b9060009160019060015491610e0883610324565b9260018116908115610d655750600114610e2157505050565b909192935060016000527fb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6906000915b848310610e5f575050500190565b8181602092548587015201920191610e51565b60025460009291610e8282610324565b91600190818116908115610d655750600114610e9d57505050565b909192935060026000527f405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace906000915b848310610edb575050500190565b8181602092548587015201920191610ecd565b60035460009291610efe82610324565b91600190818116908115610d655750600114610f1957505050565b909192935060036000527fc2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85b906000915b848310610f57575050500190565b8181602092548587015201920191610f49565b90610f7d60209282815194859201610123565b0190565b6005546001600160a01b031690610fa2610f9a8261164c565b919092612296565b911561124c57610fb190612296565b915b604051631c10ed5560e31b808252916001600160a01b03169060008180610fdc60048201610c2f565b0381855afa90811561123357600091610ffc918391611238575b506123da565b60405193845260206004850152601660248501527567756e7a6970536372697074732d302e302e312e6a7360501b60448501529291829060649082905afa8015611233576110519160009161121057506123da565b906040519384936020850161106590610ce9565b7f3c7363726970743e77696e646f772e6c6f636174696f6e2e686173683d0000008152601d0161109491610f6a565b7f3b77696e646f772e6261636b67726f756e644f766572726964653d00000000008152601b016110c391610f6a565b691d9e17b9b1b934b83a1f60b11b8152600a017f3c73637269707420747970653d22746578742f6a6176617363726970742b677a81527f697022207372633d22646174613a746578742f6a6176617363726970743b62616020820152641cd94d8d0b60da1b604082015260450161113991610f6a565b6a111f1e17b9b1b934b83a1f60a91b8152600b017f3c736372697074207372633d22646174613a746578742f6a61766173637269708152681d0ed8985cd94d8d0b60ba1b602082015260290161118e91610f6a565b6a111f1e17b9b1b934b83a1f60a91b8152600b016111ab90610d78565b0390601f199182810182526111c090826103b1565b6111c9906124e7565b6040517519185d184e9d195e1d0bda1d1b5b0ed8985cd94d8d0b60521b602082015291908290603682015b6111fd91610f6a565b03908101825261120d90826103b1565b90565b61122d91503d806000833e61122581836103b1565b810190610b42565b38610ff6565b610cdd565b61122d91503d8085833e61122581836103b1565b50611255610b10565b91610fb3565b6040519061126882610374565b60048252634869646560e01b6020830152565b6040519061128882610374565b600482526353686f7760e01b6020830152565b604090815190602090826112b6838201928360209181520190565b03926112ca601f19948581018352826103b1565b51902092600b8406159381516112f7816112eb868201948560209181520190565b038681018352826103b1565b51902093808015958661160e575b835185810191825261132281602084015b038881018352826103b1565b5190208196611605575b86156115f9575b83518581019182526113488160208401611316565b51902083518581018281529061136981602084015b038981018352826103b1565b5190209161139d85518781019061139481611388888560209181520190565b038b81018352826103b1565b51902060031690565b1593156115eb576113ac61127b565b975b156115dd576113bb61127b565b905b156115cd5760036113cc61127b565b925b166115bd57600f6113dd61127b565b935b166115af576113ec61127b565b935b156115a1576113fb61127b565b945b51605b60f81b9681019687529788966001017f7b2274726169745f74797065223a2252656374616e676c6573222c2276616c7581526332911d1160e11b602082015260240161144b91610f6a565b62089f4b60ea1b81526003017f7b2274726169745f74797065223a22506f6c79676f6e222c2276616c7565223a8152601160f91b602082015260210161149091610f6a565b62089f4b60ea1b81526003017f7b2274726169745f74797065223a22486f6c65222c2276616c7565223a2200008152601e016114cb91610f6a565b62089f4b60ea1b81526003017f7b2274726169745f74797065223a2247726964222c2276616c7565223a2200008152601e0161150691610f6a565b62089f4b60ea1b81526003017f7b2274726169745f74797065223a2253746172222c2276616c7565223a2200008152601e0161154191610f6a565b62089f4b60ea1b81526003017f7b2274726169745f74797065223a224f726e616d656e74222c2276616c7565228152611d1160f11b602082015260220161158791610f6a565b61227d60f01b8152600201605d60f81b81526001016111fd565b6115a961125b565b946113fd565b6115b761125b565b936113ee565b600f6115c761125b565b936113df565b60036115d761125b565b926113ce565b6115e561125b565b906113bd565b6115f361125b565b976113ae565b60018116159650611333565b8215965061132c565b60018116159250611305565b61162390612296565b61120d60206040518361163f8295518092858086019101610123565b81010380845201826103b1565b90604060018060a01b036006541692602482518095819363111e520f60e31b835260048301525afa91821561123357600090819361168957509190565b9092506040813d6040116116c5575b816116a5604093836103b1565b810103126116c157805192831515840361027a57506020015190565b8280fd5b3d9150611698565b604051906116da82610374565b600e82526d726762283132332c35302c35302960901b6020830152565b6040519061170482610374565b600e82526d7267622835302c3132332c35302960901b6020830152565b6040519061172e82610374565b600e82526d7267622835302c35302c3132332960901b6020830152565b634e487b7160e01b600052603260045260246000fd5b9060038110156117725760051b0190565b61174b565b6040519061178482610374565b600b82526a1d1c985b9cdc185c995b9d60aa1b6020830152565b604051906117ab82610374565b6005825264626c61636b60d81b6020830152565b604051906117cc82610374565b601882527f6261636b67726f756e642d636f6c6f723a20626c61636b3b00000000000000006020830152565b6040519061180582610374565b6005825264776869746560d81b6020830152565b6040519061182682610374565b601882527f6261636b67726f756e642d636f6c6f723a2077686974653b00000000000000006020830152565b6040519061185f82610374565b600582526431b7b637b960d91b6020830152565b600b60fa1b815260010190565b634e487b7160e01b600052601160045260246000fd5b919082039182116118a357565b611880565b90600282018092116118a357565b90602082018092116118a357565b919082018092116118a357565b604051906118de82610374565b60048252636772617960e01b6020830152565b604051906118fe82610374565b600c82526b3c7374796c653e737667207b60a01b6020830152565b6040908151906119ba60209182840184611937838360209181520190565b039461194b601f19968781018352826103b1565b519020611956610987565b9161195f6116cd565b83526119696116f7565b85840152611975611721565b878401526119c661198a600384068095611761565b5188519586916119b4898401601190703130b1b5b3b937bab73216b1b7b637b91d60791b81520190565b90610f6a565b038781018652856103b1565b8651858101838152906119dc816020840161135d565b51902092600b8406612115576001935b8851878101918252611a088160208401038a81018352826103b1565b5190206006810661210d576001905b8951888101918252611a2c8160208401611388565b51902090611a39826125d0565b611a428561164c565b91600091156120c8575050955b8661207c5715611bb6575050611a6490612296565b93905b611a6f6118f1565b93611a7990612296565b92611a83906126a2565b8851607d60f81b88820190815290948592916001016862675374796c65207b60b81b8152600901611ab391610f6a565b601d60f91b8152600101611ac691610f6a565b607d60f81b8152600101671e17b9ba3cb6329f60c11b8152600801038781018452611af190846103b1565b611afa90612296565b875194859491611b0b888701610df4565b611b1491610f6a565b611b1d90610e72565b651e3730b6b29f60d11b8152600601611b3591610f6a565b661e17b730b6b29f60c91b8152600701611b4e91610f6a565b611b5791610f6a565b611b6091610f6a565b611b6990610eee565b038381018252611b7990826103b1565b611b82906124e7565b92517f646174613a696d6167652f7376672b786d6c3b6261736536342c000000000000918101918252928391601a016111f4565b91509450600014611dde57611bc96118d1565b87518681019586529094908060208301038881018252611be990826103b1565b5190208751868101828152908060208301038981018252611c0a90826103b1565b519020906097820691611c1c83612296565b611c2584612296565b93611c2f90612296565b8b519485928b8401611c4c90600490630e4cec4560e31b81520190565b611c5591610f6a565b611c5e90611873565b611c6791610f6a565b611c7090611873565b611c7991610f6a565b602960f81b8152600101038981018452611c9390846103b1565b89518881019182528060208301038a81018252611cb090826103b1565b519020611cbc90612638565b90611cc682612296565b611ccf83612296565b92611cd990612296565b8b519384928b8401611cf690600490630e4cec4560e31b81520190565b611cff91610f6a565b611d0890611873565b611d1191610f6a565b611d1a90611873565b611d2391610f6a565b602960f81b8152600101038981018352611d3d90836103b1565b605b9006611d4a90612296565b908951928392898401611d8190601c907f6261636b67726f756e643a206c696e6561722d6772616469656e74280000000081520190565b611d8a91610f6a565b6403232b396160dd1b8152600501611da191610f6a565b64010181296160dd1b8152600501611db891610f6a565b662031303025293b60c81b8152600701038781018252611dd890826103b1565b90611a67565b611de6611852565b87518681019586529094908060208301038881018252611e0690826103b1565b5190208751868101828152908060208301038981018252611e2790826103b1565b51902090611e34826125e2565b89518881019384529092908060208301038a81018252611e5490826103b1565b51902090611e6282846125f4565b8a518981019384529092908060208301038b81018252611e8290826103b1565b519020918a611e9184866125f4565b81518b81019586529094908060208301038d81018252611eb190826103b1565b5190209485611ebf916125f4565b918b611eca82612296565b968c611ed588612296565b611ede87612296565b9086519a8b938401611efb90600490630e4cec4560e31b81520190565b611f0491610f6a565b611f0d90611873565b611f1691610f6a565b611f1f90611873565b611f2891610f6a565b602960f81b8152600101038281018952611f4290896103b1565b8351808e019182528060208301038381018252611f5f90826103b1565b519020611fa291611f8c90611f98908f60018516612074576001975b519384918201958660209181520190565b039081018352826103b1565b5190206065900690565b91156120135790611fe4611fb982611ff4946118c4565b60ff9290818482111561200a57611fd39150845b986118c4565b838111156120055750825b946118c4565b81811115611ffe57505b93612296565b90611ccf90612296565b9050611fee565b611fde565b611fd391611fcd565b818181111561206657505060005b93818181111561205857505060005b9180821115612046575050611ff4600093612296565b611ff49161205391611896565b611fee565b61206191611896565b612030565b61206f91611896565b612021565b600097611f7b565b5050505092506001821460001461209e576120956117f8565b92611dd8611819565b600282036120b7576120ae61179e565b92611dd86117bf565b6120bf611777565b92611dd86103d3565b909150600781116120df575060ff905b1695611a4f565b600881116120f257505060ff60016120d8565b60091090506121045760ff60026120d8565b60ff60036120d8565b600090611a17565b6000936119ec565b9061212661264a565b815167ffffffffffffffff81116103905761214b81612146600754610324565b612204565b602080601f831160011461218e5750819061217e9394600092612183575b50508160011b916000199060031b1c19161790565b600755565b015190503880612169565b90601f198316946121af600760005260008051602061286183398151915290565b926000905b8782106121ec5750508360019596106121d3575b505050811b01600755565b015160001960f88460031b161c191690553880806121c8565b806001859682949686015181550195019301906121b4565b601f8111612210575050565b6000906007600052600080516020612861833981519152906020601f850160051c8301941061225a575b601f0160051c01915b82811061224f57505050565b818155600101612243565b909250829061223a565b9061226e82610994565b61227b60405191826103b1565b828152809261228c601f1991610994565b0190602036910137565b806000917a184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000808210156123cc575b506d04ee2d6d415b85acef8100000000808310156123bd575b50662386f26fc10000808310156123ae575b506305f5e1008083101561239f575b5061271080831015612390575b506064821015612380575b600a80921015612376575b60019081602161232e60018701612264565b95860101905b612340575b5050505090565b600019019083906f181899199a1a9b1b9c1cb0b131b232b360811b8282061a83530491821561237157919082612334565b612339565b916001019161231c565b9190606460029104910191612311565b60049193920491019138612306565b600891939204910191386122f9565b601091939204910191386122ea565b602091939204910191386122d8565b6040935081049150386122bf565b906020809201518051906020916040805195600080945b84861061241157505050505050601f801991828101855201168201604052565b909192939495838760051b8301015180518686830151920151813b808211612452575082849392600195938e930394859301903c01960194939291906123f1565b9260849387936386d14d8960e01b8552600452602452604452606452fd5b6040519061247d82610395565b604082527f6768696a6b6c6d6e6f707172737475767778797a303132333435363738392b2f6040837f4142434445464748494a4b4c4d4e4f505152535455565758595a61626364656660208201520152565b600281901b91906001600160fe1b038116036118a357565b8051156125c7576124f6612470565b61251261250d61250684516118a8565b6003900490565b6124cf565b9161252461251f846118b6565b612264565b92835280815182019060208501935b8282106125755750505060039051068060011461256457600214612555575090565b603d60f81b6000199091015290565b50613d3d60f01b6001199091015290565b9091936004906003809401938451600190603f9082828260121c16880101518553828282600c1c16880101518386015382828260061c1688010151600286015316850101519082015301939190612533565b5061120d610aec565b600a9006600181018091116118a35790565b60339006606481018091116118a35790565b603119810191908083116118a357603019018092116118a35781156126225706603281018091116118a35790565b634e487b7160e01b600052601260045260246000fd5b606a9006609681018091116118a35790565b6000546001600160a01b0316330361265e57565b606460405162461bcd60e51b815260206004820152602060248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152fd5b8060009060008360801c806127c4575b508160401c806127b9575b508160201c806127ad575b506001906010928060101c806127a0575b5060081c612799575b01600181901b9392906001600160ff1b03811681036118a35761273861273d9161270f8796959496610994565b9661271d60405198896103b1565b80885261272c601f1991610994565b013660208901376127cf565b6127e0565b925b8084121561275457505061120d915015612815565b9091600f8116908382101561177257612791916f181899199a1a9b1b9c1cb0b131b232b360811b901a6127878688612804565b5360041c936127f2565b92919061273f565b81016126e2565b60029150910190386126d9565b915060040160016126c8565b9150600801386126bd565b9150506010386126b2565b908160011b9160028305036118a357565b9060001982019182136001166118a357565b600160ff1b81146118a3576000190190565b908151811015611772570160200190565b1561281c57565b606460405162461bcd60e51b815260206004820152602060248201527f537472696e67733a20686578206c656e67746820696e73756666696369656e746044820152fdfea66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c688a26469706673582212200e0c25f01b7c3ac077845fbdc33ac7de4212763a8de160de42c79a6877c953be64736f6c63430008160033000000000000000000000000fe1411d6864592549ade050215482e4385dfa0fb

0x6080604052600436101561001257600080fd5b60003560e01c8063102581d21461010757806315c63984146101025780633c356268146100fd5780634378a6e3146100f85780636b8ff574146100f3578063715018a6146100ee5780638526d3b9146100e957806388f29078146100e45780638da5cb5b146100df578063a2932558146100da578063a574cea4146100d5578063b6482aad146100d0578063be985ac9146100cb578063f0099a75146100c65763f2fde38b146100c157600080fd5b610a25565b6109b0565b61096e565b610927565b61055d565b610499565b6102fb565b6102d5565b61028e565b61021f565b610206565b6101ed565b6101c4565b61019b565b610172565b602090600319011261011e5760043590565b600080fd5b60005b8381106101365750506000910152565b8181015183820152602001610126565b604091602082526101668151809281602086015260208686019101610123565b601f01601f1916010190565b3461011e5761019761018b6101863661010c565b610f81565b60405191829182610146565b0390f35b3461011e57600036600319011261011e576006546040516001600160a01b039091168152602090f35b3461011e57600036600319011261011e576005546040516001600160a01b039091168152602090f35b3461011e5761019761018b6102013661010c565b61129b565b3461011e5761019761018b61021a3661010c565b61161a565b3461011e5760008060031936011261027a5761023961264a565b80546001600160a01b03198116825581906001600160a01b03167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e08280a380f35b80fd5b6001600160a01b0381160361011e57565b3461011e57602036600319011261011e576004356102ab8161027d565b6102b361264a565b600680546001600160a01b0319166001600160a01b0392909216919091179055005b3461011e5760406102ed6102e83661010c565b61164c565b825191151582526020820152f35b3461011e57600036600319011261011e576000546040516001600160a01b039091168152602090f35b90600182811c92168015610354575b602083101461033e57565b634e487b7160e01b600052602260045260246000fd5b91607f1691610333565b634e487b7160e01b600052604160045260246000fd5b6040810190811067ffffffffffffffff82111761039057604052565b61035e565b6060810190811067ffffffffffffffff82111761039057604052565b90601f8019910116810190811067ffffffffffffffff82111761039057604052565b60405190600082600454916103e783610324565b808352926020906001908181169081156104755750600114610414575b5050610412925003836103b1565b565b91509260046000527f8a35acfbc15ff81a39ae7d344fd709f28e8600b4aa8c65c6b64bfe7fe36bd19b936000925b82841061045d57506104129450505081016020013880610404565b85548885018301529485019487945092810192610442565b9150506020925061041294915060ff191682840152151560051b8201013880610404565b3461011e5760008060031936011261027a576040519080600754906104bd82610324565b8085529160209160019182811690811561053057506001146104ea575b6101978661018b818803826103b1565b9350600784526000805160206128618339815191525b83851061051d5750505050810160200161018b82610197386104da565b8054868601840152938201938101610500565b90508695506101979693506020925061018b94915060ff191682840152151560051b8201019293386104da565b3461011e5761056b3661010c565b61057481611919565b9061057e8161161a565b9061058881612296565b9061059281612296565b61059b82610f81565b916105a59061129b565b6040517f7b226e616d65223a2253656c656374696f6e204e6f2e200000000000000000006020820152958695919491603787016105e191610f6a565b61088b60f21b81526002017f226465736372697074696f6e223a2022496e2053656c656374696f6e2c20746881527f6520666f637573206f662074686520776f726b20697320666f6375732069747360208201526932b633172e372e372e3760b11b6040820152604a017f5468652070726f6a65637420697320612066756c6c79206f6e2d636861696e2081527f67656e65726174656420636f6c6c656374696f6e206f662073656c656374696f60208201527f6e2061726561732c207468652066616d696c696172206d61726368696e67206160408201527f6e747320636f6e6365697665642062792042696c6c2041746b696e736f6e207760608201527f686963682068617665206265636f6d652073756368206120756269717569746f60808201527f75732070617274206f6620696e746572666163652063756c747572652e5c6e5c60a082015262372e3760e91b60c082015260c3017f53656c656374696f6e2069732072656c656173656420696e20706172746e657281526f39b434b8103bb4ba34102337b634b09760811b60208201526030016b11161134b6b0b3b2911d101160a11b8152600c016107999082610f6a565b61088b60f21b81526002016d1134b6b0b3b2afbab936111d101160911b8152600e016107c491610f6a565b61088b60f21b81526002017f22686f6d655f75726c223a202268747470733a2f2f73656c656374696f6e2e668152686f6c69612e6170702360b81b602082015260290161081091610f6a565b7f222c2265787465726e616c5f75726c223a202268747470733a2f2f73656c656381526e74696f6e2e666f6c69612e6170702360881b6020820152602f0161085791610f6a565b7211161130b734b6b0ba34b7b72fbab936111d1160691b815260130161087c91610f6a565b61088b60f21b81526002016d01130ba3a3934b13aba32b9911d160951b8152600e016108a791610f6a565b607d60f81b81526001010390601f199182810182526108c690826103b1565b6108cf906124e7565b6040517f646174613a6170706c69636174696f6e2f6a736f6e3b6261736536342c000000602082015291908290603d820161090991610f6a565b03908101825261091990826103b1565b604051610197819282610146565b3461011e57602036600319011261011e576004356109448161027d565b61094c61264a565b600580546001600160a01b0319166001600160a01b0392909216919091179055005b3461011e5761019761018b6109823661010c565b611919565b6040519061041282610395565b67ffffffffffffffff811161039057601f01601f191660200190565b3461011e57602036600319011261011e5760043567ffffffffffffffff811161011e573660238201121561011e5780600401356109ec81610994565b906109fa60405192836103b1565b808252366024828501011161011e576020816000926024610a239601838601378301015261211d565b005b3461011e57602036600319011261011e57600435610a428161027d565b610a4a61264a565b6001600160a01b039081168015610a9857600080546001600160a01b03198116831782559092167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e08380a380f35b60405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608490fd5b604051906020820182811067ffffffffffffffff8211176103905760405260008252565b60405190610b1d82610374565b600582526466616c736560d81b6020830152565b519063ffffffff8216820361011e57565b906020808383031261011e57825167ffffffffffffffff9384821161011e570192604092838582031261011e57835194610b7b86610374565b80518652838101519083821161011e57019080601f8301121561011e57815192831161039057845194610bb3858560051b01876103b1565b838652848601918560608096028501019381851161011e578601925b848410610be25750505050505082015290565b858483031261011e578686918451610bf981610395565b8651610c048161027d565b8152610c11838801610b31565b83820152610c20868801610b31565b86820152815201930192610bcf565b6020808252600754600092610c4382610324565b918260208301526040600191600181169081600014610cba5750600114610c6d575b505050505090565b60076000908152949695509192916000805160206128618339815191525b838610610ca75750505050604092935001013880808080610c65565b8054858701830152948701948201610c8b565b9395505050506040935060ff191683830152151560051b01013880808080610c65565b6040513d6000823e3d90fd5b60085460009291610cf982610324565b91600190818116908115610d655750600114610d1457505050565b909192935060086000527ff3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee3906000915b848310610d52575050500190565b8181602092548587015201920191610d44565b60ff191683525050811515909102019150565b60095460009291610d8882610324565b91600190818116908115610d655750600114610da357505050565b909192935060096000527f6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7af906000915b848310610de1575050500190565b8181602092548587015201920191610dd3565b9060009160019060015491610e0883610324565b9260018116908115610d655750600114610e2157505050565b909192935060016000527fb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6906000915b848310610e5f575050500190565b8181602092548587015201920191610e51565b60025460009291610e8282610324565b91600190818116908115610d655750600114610e9d57505050565b909192935060026000527f405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace906000915b848310610edb575050500190565b8181602092548587015201920191610ecd565b60035460009291610efe82610324565b91600190818116908115610d655750600114610f1957505050565b909192935060036000527fc2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85b906000915b848310610f57575050500190565b8181602092548587015201920191610f49565b90610f7d60209282815194859201610123565b0190565b6005546001600160a01b031690610fa2610f9a8261164c565b919092612296565b911561124c57610fb190612296565b915b604051631c10ed5560e31b808252916001600160a01b03169060008180610fdc60048201610c2f565b0381855afa90811561123357600091610ffc918391611238575b506123da565b60405193845260206004850152601660248501527567756e7a6970536372697074732d302e302e312e6a7360501b60448501529291829060649082905afa8015611233576110519160009161121057506123da565b906040519384936020850161106590610ce9565b7f3c7363726970743e77696e646f772e6c6f636174696f6e2e686173683d0000008152601d0161109491610f6a565b7f3b77696e646f772e6261636b67726f756e644f766572726964653d00000000008152601b016110c391610f6a565b691d9e17b9b1b934b83a1f60b11b8152600a017f3c73637269707420747970653d22746578742f6a6176617363726970742b677a81527f697022207372633d22646174613a746578742f6a6176617363726970743b62616020820152641cd94d8d0b60da1b604082015260450161113991610f6a565b6a111f1e17b9b1b934b83a1f60a91b8152600b017f3c736372697074207372633d22646174613a746578742f6a61766173637269708152681d0ed8985cd94d8d0b60ba1b602082015260290161118e91610f6a565b6a111f1e17b9b1b934b83a1f60a91b8152600b016111ab90610d78565b0390601f199182810182526111c090826103b1565b6111c9906124e7565b6040517519185d184e9d195e1d0bda1d1b5b0ed8985cd94d8d0b60521b602082015291908290603682015b6111fd91610f6a565b03908101825261120d90826103b1565b90565b61122d91503d806000833e61122581836103b1565b810190610b42565b38610ff6565b610cdd565b61122d91503d8085833e61122581836103b1565b50611255610b10565b91610fb3565b6040519061126882610374565b60048252634869646560e01b6020830152565b6040519061128882610374565b600482526353686f7760e01b6020830152565b604090815190602090826112b6838201928360209181520190565b03926112ca601f19948581018352826103b1565b51902092600b8406159381516112f7816112eb868201948560209181520190565b038681018352826103b1565b51902093808015958661160e575b835185810191825261132281602084015b038881018352826103b1565b5190208196611605575b86156115f9575b83518581019182526113488160208401611316565b51902083518581018281529061136981602084015b038981018352826103b1565b5190209161139d85518781019061139481611388888560209181520190565b038b81018352826103b1565b51902060031690565b1593156115eb576113ac61127b565b975b156115dd576113bb61127b565b905b156115cd5760036113cc61127b565b925b166115bd57600f6113dd61127b565b935b166115af576113ec61127b565b935b156115a1576113fb61127b565b945b51605b60f81b9681019687529788966001017f7b2274726169745f74797065223a2252656374616e676c6573222c2276616c7581526332911d1160e11b602082015260240161144b91610f6a565b62089f4b60ea1b81526003017f7b2274726169745f74797065223a22506f6c79676f6e222c2276616c7565223a8152601160f91b602082015260210161149091610f6a565b62089f4b60ea1b81526003017f7b2274726169745f74797065223a22486f6c65222c2276616c7565223a2200008152601e016114cb91610f6a565b62089f4b60ea1b81526003017f7b2274726169745f74797065223a2247726964222c2276616c7565223a2200008152601e0161150691610f6a565b62089f4b60ea1b81526003017f7b2274726169745f74797065223a2253746172222c2276616c7565223a2200008152601e0161154191610f6a565b62089f4b60ea1b81526003017f7b2274726169745f74797065223a224f726e616d656e74222c2276616c7565228152611d1160f11b602082015260220161158791610f6a565b61227d60f01b8152600201605d60f81b81526001016111fd565b6115a961125b565b946113fd565b6115b761125b565b936113ee565b600f6115c761125b565b936113df565b60036115d761125b565b926113ce565b6115e561125b565b906113bd565b6115f361125b565b976113ae565b60018116159650611333565b8215965061132c565b60018116159250611305565b61162390612296565b61120d60206040518361163f8295518092858086019101610123565b81010380845201826103b1565b90604060018060a01b036006541692602482518095819363111e520f60e31b835260048301525afa91821561123357600090819361168957509190565b9092506040813d6040116116c5575b816116a5604093836103b1565b810103126116c157805192831515840361027a57506020015190565b8280fd5b3d9150611698565b604051906116da82610374565b600e82526d726762283132332c35302c35302960901b6020830152565b6040519061170482610374565b600e82526d7267622835302c3132332c35302960901b6020830152565b6040519061172e82610374565b600e82526d7267622835302c35302c3132332960901b6020830152565b634e487b7160e01b600052603260045260246000fd5b9060038110156117725760051b0190565b61174b565b6040519061178482610374565b600b82526a1d1c985b9cdc185c995b9d60aa1b6020830152565b604051906117ab82610374565b6005825264626c61636b60d81b6020830152565b604051906117cc82610374565b601882527f6261636b67726f756e642d636f6c6f723a20626c61636b3b00000000000000006020830152565b6040519061180582610374565b6005825264776869746560d81b6020830152565b6040519061182682610374565b601882527f6261636b67726f756e642d636f6c6f723a2077686974653b00000000000000006020830152565b6040519061185f82610374565b600582526431b7b637b960d91b6020830152565b600b60fa1b815260010190565b634e487b7160e01b600052601160045260246000fd5b919082039182116118a357565b611880565b90600282018092116118a357565b90602082018092116118a357565b919082018092116118a357565b604051906118de82610374565b60048252636772617960e01b6020830152565b604051906118fe82610374565b600c82526b3c7374796c653e737667207b60a01b6020830152565b6040908151906119ba60209182840184611937838360209181520190565b039461194b601f19968781018352826103b1565b519020611956610987565b9161195f6116cd565b83526119696116f7565b85840152611975611721565b878401526119c661198a600384068095611761565b5188519586916119b4898401601190703130b1b5b3b937bab73216b1b7b637b91d60791b81520190565b90610f6a565b038781018652856103b1565b8651858101838152906119dc816020840161135d565b51902092600b8406612115576001935b8851878101918252611a088160208401038a81018352826103b1565b5190206006810661210d576001905b8951888101918252611a2c8160208401611388565b51902090611a39826125d0565b611a428561164c565b91600091156120c8575050955b8661207c5715611bb6575050611a6490612296565b93905b611a6f6118f1565b93611a7990612296565b92611a83906126a2565b8851607d60f81b88820190815290948592916001016862675374796c65207b60b81b8152600901611ab391610f6a565b601d60f91b8152600101611ac691610f6a565b607d60f81b8152600101671e17b9ba3cb6329f60c11b8152600801038781018452611af190846103b1565b611afa90612296565b875194859491611b0b888701610df4565b611b1491610f6a565b611b1d90610e72565b651e3730b6b29f60d11b8152600601611b3591610f6a565b661e17b730b6b29f60c91b8152600701611b4e91610f6a565b611b5791610f6a565b611b6091610f6a565b611b6990610eee565b038381018252611b7990826103b1565b611b82906124e7565b92517f646174613a696d6167652f7376672b786d6c3b6261736536342c000000000000918101918252928391601a016111f4565b91509450600014611dde57611bc96118d1565b87518681019586529094908060208301038881018252611be990826103b1565b5190208751868101828152908060208301038981018252611c0a90826103b1565b519020906097820691611c1c83612296565b611c2584612296565b93611c2f90612296565b8b519485928b8401611c4c90600490630e4cec4560e31b81520190565b611c5591610f6a565b611c5e90611873565b611c6791610f6a565b611c7090611873565b611c7991610f6a565b602960f81b8152600101038981018452611c9390846103b1565b89518881019182528060208301038a81018252611cb090826103b1565b519020611cbc90612638565b90611cc682612296565b611ccf83612296565b92611cd990612296565b8b519384928b8401611cf690600490630e4cec4560e31b81520190565b611cff91610f6a565b611d0890611873565b611d1191610f6a565b611d1a90611873565b611d2391610f6a565b602960f81b8152600101038981018352611d3d90836103b1565b605b9006611d4a90612296565b908951928392898401611d8190601c907f6261636b67726f756e643a206c696e6561722d6772616469656e74280000000081520190565b611d8a91610f6a565b6403232b396160dd1b8152600501611da191610f6a565b64010181296160dd1b8152600501611db891610f6a565b662031303025293b60c81b8152600701038781018252611dd890826103b1565b90611a67565b611de6611852565b87518681019586529094908060208301038881018252611e0690826103b1565b5190208751868101828152908060208301038981018252611e2790826103b1565b51902090611e34826125e2565b89518881019384529092908060208301038a81018252611e5490826103b1565b51902090611e6282846125f4565b8a518981019384529092908060208301038b81018252611e8290826103b1565b519020918a611e9184866125f4565b81518b81019586529094908060208301038d81018252611eb190826103b1565b5190209485611ebf916125f4565b918b611eca82612296565b968c611ed588612296565b611ede87612296565b9086519a8b938401611efb90600490630e4cec4560e31b81520190565b611f0491610f6a565b611f0d90611873565b611f1691610f6a565b611f1f90611873565b611f2891610f6a565b602960f81b8152600101038281018952611f4290896103b1565b8351808e019182528060208301038381018252611f5f90826103b1565b519020611fa291611f8c90611f98908f60018516612074576001975b519384918201958660209181520190565b039081018352826103b1565b5190206065900690565b91156120135790611fe4611fb982611ff4946118c4565b60ff9290818482111561200a57611fd39150845b986118c4565b838111156120055750825b946118c4565b81811115611ffe57505b93612296565b90611ccf90612296565b9050611fee565b611fde565b611fd391611fcd565b818181111561206657505060005b93818181111561205857505060005b9180821115612046575050611ff4600093612296565b611ff49161205391611896565b611fee565b61206191611896565b612030565b61206f91611896565b612021565b600097611f7b565b5050505092506001821460001461209e576120956117f8565b92611dd8611819565b600282036120b7576120ae61179e565b92611dd86117bf565b6120bf611777565b92611dd86103d3565b909150600781116120df575060ff905b1695611a4f565b600881116120f257505060ff60016120d8565b60091090506121045760ff60026120d8565b60ff60036120d8565b600090611a17565b6000936119ec565b9061212661264a565b815167ffffffffffffffff81116103905761214b81612146600754610324565b612204565b602080601f831160011461218e5750819061217e9394600092612183575b50508160011b916000199060031b1c19161790565b600755565b015190503880612169565b90601f198316946121af600760005260008051602061286183398151915290565b926000905b8782106121ec5750508360019596106121d3575b505050811b01600755565b015160001960f88460031b161c191690553880806121c8565b806001859682949686015181550195019301906121b4565b601f8111612210575050565b6000906007600052600080516020612861833981519152906020601f850160051c8301941061225a575b601f0160051c01915b82811061224f57505050565b818155600101612243565b909250829061223a565b9061226e82610994565b61227b60405191826103b1565b828152809261228c601f1991610994565b0190602036910137565b806000917a184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000808210156123cc575b506d04ee2d6d415b85acef8100000000808310156123bd575b50662386f26fc10000808310156123ae575b506305f5e1008083101561239f575b5061271080831015612390575b506064821015612380575b600a80921015612376575b60019081602161232e60018701612264565b95860101905b612340575b5050505090565b600019019083906f181899199a1a9b1b9c1cb0b131b232b360811b8282061a83530491821561237157919082612334565b612339565b916001019161231c565b9190606460029104910191612311565b60049193920491019138612306565b600891939204910191386122f9565b601091939204910191386122ea565b602091939204910191386122d8565b6040935081049150386122bf565b906020809201518051906020916040805195600080945b84861061241157505050505050601f801991828101855201168201604052565b909192939495838760051b8301015180518686830151920151813b808211612452575082849392600195938e930394859301903c01960194939291906123f1565b9260849387936386d14d8960e01b8552600452602452604452606452fd5b6040519061247d82610395565b604082527f6768696a6b6c6d6e6f707172737475767778797a303132333435363738392b2f6040837f4142434445464748494a4b4c4d4e4f505152535455565758595a61626364656660208201520152565b600281901b91906001600160fe1b038116036118a357565b8051156125c7576124f6612470565b61251261250d61250684516118a8565b6003900490565b6124cf565b9161252461251f846118b6565b612264565b92835280815182019060208501935b8282106125755750505060039051068060011461256457600214612555575090565b603d60f81b6000199091015290565b50613d3d60f01b6001199091015290565b9091936004906003809401938451600190603f9082828260121c16880101518553828282600c1c16880101518386015382828260061c1688010151600286015316850101519082015301939190612533565b5061120d610aec565b600a9006600181018091116118a35790565b60339006606481018091116118a35790565b603119810191908083116118a357603019018092116118a35781156126225706603281018091116118a35790565b634e487b7160e01b600052601260045260246000fd5b606a9006609681018091116118a35790565b6000546001600160a01b0316330361265e57565b606460405162461bcd60e51b815260206004820152602060248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152fd5b8060009060008360801c806127c4575b508160401c806127b9575b508160201c806127ad575b506001906010928060101c806127a0575b5060081c612799575b01600181901b9392906001600160ff1b03811681036118a35761273861273d9161270f8796959496610994565b9661271d60405198896103b1565b80885261272c601f1991610994565b013660208901376127cf565b6127e0565b925b8084121561275457505061120d915015612815565b9091600f8116908382101561177257612791916f181899199a1a9b1b9c1cb0b131b232b360811b901a6127878688612804565b5360041c936127f2565b92919061273f565b81016126e2565b60029150910190386126d9565b915060040160016126c8565b9150600801386126bd565b9150506010386126b2565b908160011b9160028305036118a357565b9060001982019182136001166118a357565b600160ff1b81146118a3576000190190565b908151811015611772570160200190565b1561281c57565b606460405162461bcd60e51b815260206004820152602060248201527f537472696e67733a20686578206c656e67746820696e73756666696369656e746044820152fdfea66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c688a26469706673582212200e0c25f01b7c3ac077845fbdc33ac7de4212763a8de160de42c79a6877c953be64736f6c63430008160033

000000000000000000000000fe1411d6864592549ade050215482e4385dfa0fb

-----Decoded View---------------
Arg [0] : ethfsAddress_ (address): 0xFe1411d6864592549AdE050215482e4385dFa0FB

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000fe1411d6864592549ade050215482e4385dfa0fb