Token Gnosis Builders NFT

Overview ERC721

Total Supply:
143 GNB

Holders:
133 addresses
Balance
0 GNB
0x0000000000000000000000000000000000000000
Loading
[ Download CSV Export  ] 
Loading
Loading

Click here to update the token ICO / general information
# Exchange Pair Price  24H Volume % Volume

Similar Match Source Code
Note: This contract matches the deployed ByteCode of the Source Code for Contract 0xff07cc4f890901867a5c6d3313aff3d87699fc03

Contract Name:
GnosisBuilder

Compiler Version
v0.8.4+commit.c7e474f2

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2023-01-17
*/

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

// File contracts/interfaces/IGnosisBuilder.sol

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

interface IGnosisBuilder {
    function safeMint(address to, string memory uri) external returns (uint256);
    function totalSupply() external returns (uint256);    
}


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

// 
// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)

pragma solidity ^0.8.0;

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

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

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

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

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


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

// 
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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


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

// 
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

/**
 * @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 anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

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

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


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

// 
// OpenZeppelin Contracts (last updated v4.8.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
     * ====
     *
     * [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://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

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

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


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

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


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

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


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

// 
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

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


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

// 
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;

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

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

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


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

// 
// OpenZeppelin Contracts (last updated v4.8.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) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 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 10, 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 * 8) < value ? 1 : 0);
        }
    }
}


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

// 
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

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


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

// 
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

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


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

// 
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.0;







/**
 * @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 {
        if (batchSize > 1) {
            if (from != address(0)) {
                _balances[from] -= batchSize;
            }
            if (to != address(0)) {
                _balances[to] += batchSize;
            }
        }
    }

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


// File contracts/GnosisBuilder.sol

// 
pragma solidity ^0.8.4;




contract GnosisBuilder is
    ERC721,
    Ownable,
    IGnosisBuilder
{
    using Strings for uint256;
    using Counters for Counters.Counter;

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

    Counters.Counter private _tokenIdCounter;

    constructor() ERC721("Gnosis Builders NFT", "GNB") {}

    function safeMint(address to, string memory uri)
        public
        override
        onlyOwner
        returns (uint256)
    {
        uint256 tokenId = _tokenIdCounter.current();
        _tokenIdCounter.increment();
        _safeMint(to, tokenId);
        _setTokenURI(tokenId, uri);
        return tokenId;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        _requireMinted(tokenId);

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

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

        return super.tokenURI(tokenId);
    }

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

    function totalSupply()
        public
        view
        override
        returns (uint256)
    {
        return _tokenIdCounter.current();
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"string","name":"uri","type":"string"}],"name":"safeMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

56399:1923:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40480:305;;;;;;:::i;:::-;;:::i;:::-;;;5870:14:1;;5863:22;5845:41;;5833:2;5818:18;40480:305:0;;;;;;;;41408:100;;;:::i;:::-;;;;;;;:::i;42920:171::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;5168:32:1;;;5150:51;;5138:2;5123:18;42920:171:0;5105:102:1;42438:416:0;;;;;;:::i;:::-;;:::i;:::-;;58165:154;;;:::i;:::-;;;11761:25:1;;;11749:2;11734:18;58165:154:0;11716:76:1;43620:335:0;;;;;;:::i;:::-;;:::i;44026:185::-;;;;;;:::i;:::-;;:::i;41118:223::-;;;;;;:::i;:::-;;:::i;40849:207::-;;;;;;:::i;:::-;;:::i;4623:103::-;;;:::i;3975:87::-;4048:6;;-1:-1:-1;;;;;4048:6:0;3975:87;;41577:104;;;:::i;43163:155::-;;;;;;:::i;:::-;;:::i;44282:322::-;;;;;;:::i;:::-;;:::i;57160:624::-;;;;;;:::i;:::-;;:::i;56760:329::-;;;;;;:::i;:::-;;:::i;43389:164::-;;;;;;:::i;:::-;-1:-1:-1;;;;;43510:25:0;;;43486:4;43510:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;43389:164;4881:201;;;;;;:::i;:::-;;:::i;40480:305::-;40582:4;-1:-1:-1;;;;;;40619:40:0;;-1:-1:-1;;;40619:40:0;;:105;;-1:-1:-1;;;;;;;40676:48:0;;-1:-1:-1;;;40676:48:0;40619:105;:158;;;-1:-1:-1;;;;;;;;;;39009:40:0;;;40741:36;40599:178;40480:305;-1:-1:-1;;40480:305:0:o;41408:100::-;41462:13;41495:5;41488:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41408:100;:::o;42920:171::-;42996:7;43016:23;43031:7;43016:14;:23::i;:::-;-1:-1:-1;43059:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;43059:24:0;;42920:171::o;42438:416::-;42519:13;42535:23;42550:7;42535:14;:23::i;:::-;42519:39;;42583:5;-1:-1:-1;;;;;42577:11:0;:2;-1:-1:-1;;;;;42577:11:0;;;42569:57;;;;-1:-1:-1;;;42569:57:0;;10985:2:1;42569:57:0;;;10967:21:1;11024:2;11004:18;;;10997:30;11063:34;11043:18;;;11036:62;-1:-1:-1;;;11114:18:1;;;11107:31;11155:19;;42569:57:0;;;;;;;;;2597:10;-1:-1:-1;;;;;42661:21:0;;;;:62;;-1:-1:-1;42686:37:0;42703:5;2597:10;43389:164;:::i;42686:37::-;42639:173;;;;-1:-1:-1;;;42639:173:0;;11387:2:1;42639:173:0;;;11369:21:1;11426:2;11406:18;;;11399:30;11465:34;11445:18;;;11438:62;11536:31;11516:18;;;11509:59;11585:19;;42639:173:0;11359:251:1;42639:173:0;42825:21;42834:2;42838:7;42825:8;:21::i;:::-;42438:416;;;:::o;58165:154::-;58254:7;58286:25;:15;1326:14;;1234:114;58286:25;58279:32;;58165:154;:::o;43620:335::-;43815:41;2597:10;43848:7;43815:18;:41::i;:::-;43807:99;;;;-1:-1:-1;;;43807:99:0;;;;;;;:::i;:::-;43919:28;43929:4;43935:2;43939:7;43919:9;:28::i;44026:185::-;44164:39;44181:4;44187:2;44191:7;44164:39;;;;;;;;;;;;:16;:39::i;41118:223::-;41190:7;46005:16;;;:7;:16;;;;;;-1:-1:-1;;;;;46005:16:0;;41254:56;;;;-1:-1:-1;;;41254:56:0;;10632:2:1;41254:56:0;;;10614:21:1;10671:2;10651:18;;;10644:30;-1:-1:-1;;;10690:18:1;;;10683:54;10754:18;;41254:56:0;10604:174:1;40849:207:0;40921:7;-1:-1:-1;;;;;40949:19:0;;40941:73;;;;-1:-1:-1;;;40941:73:0;;9085:2:1;40941:73:0;;;9067:21:1;9124:2;9104:18;;;9097:30;9163:34;9143:18;;;9136:62;-1:-1:-1;;;9214:18:1;;;9207:39;9263:19;;40941:73:0;9057:231:1;40941:73:0;-1:-1:-1;;;;;;41032:16:0;;;;;:9;:16;;;;;;;40849:207::o;4623:103::-;3861:13;:11;:13::i;:::-;4688:30:::1;4715:1;4688:18;:30::i;:::-;4623:103::o:0;41577:104::-;41633:13;41666:7;41659:14;;;;;:::i;43163:155::-;43258:52;2597:10;43291:8;43301;43258:18;:52::i;:::-;43163:155;;:::o;44282:322::-;44456:41;2597:10;44489:7;44456:18;:41::i;:::-;44448:99;;;;-1:-1:-1;;;44448:99:0;;;;;;;:::i;:::-;44558:38;44572:4;44578:2;44582:7;44591:4;44558:13;:38::i;:::-;44282:322;;;;:::o;57160:624::-;57233:13;57259:23;57274:7;57259:14;:23::i;:::-;57295;57321:19;;;:10;:19;;;;;57295:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57351:18;57372:10;42359:9;;;;;;;;;-1:-1:-1;42359:9:0;;;42282:94;57372:10;57351:31;;57464:4;57458:18;57480:1;57458:23;57454:72;;;-1:-1:-1;57505:9:0;57160:624;-1:-1:-1;;57160:624:0:o;57454:72::-;57630:23;;:27;57626:108;;57705:4;57711:9;57688:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;57674:48;;;;57160:624;;;:::o;57626:108::-;57753:23;57768:7;57753:14;:23::i;:::-;57746:30;57160:624;-1:-1:-1;;;;57160:624:0:o;56760:329::-;56880:7;3861:13;:11;:13::i;:::-;56905:15:::1;56923:25;:15;1326:14:::0;;1234:114;56923:25:::1;56905:43;;56959:27;:15;1445:19:::0;;1463:1;1445:19;;;1356:127;56959:27:::1;56997:22;57007:2;57011:7;56997:9;:22::i;:::-;57030:26;57043:7;57052:3;57030:12;:26::i;:::-;57074:7:::0;56760:329;-1:-1:-1;;;56760:329:0:o;4881:201::-;3861:13;:11;:13::i;:::-;-1:-1:-1;;;;;4970:22:0;::::1;4962:73;;;::::0;-1:-1:-1;;;4962:73:0;;7156:2:1;4962:73:0::1;::::0;::::1;7138:21:1::0;7195:2;7175:18;;;7168:30;7234:34;7214:18;;;7207:62;-1:-1:-1;;;7285:18:1;;;7278:36;7331:19;;4962:73:0::1;7128:228:1::0;4962:73:0::1;5046:28;5065:8;5046:18;:28::i;:::-;4881:201:::0;:::o;52739:135::-;46407:4;46005:16;;;:7;:16;;;;;;-1:-1:-1;;;;;46005:16:0;52813:53;;;;-1:-1:-1;;;52813:53:0;;10632:2:1;52813:53:0;;;10614:21:1;10671:2;10651:18;;;10644:30;-1:-1:-1;;;10690:18:1;;;10683:54;10754:18;;52813:53:0;10604:174:1;52018::0;52093:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;52093:29:0;-1:-1:-1;;;;;52093:29:0;;;;;;;;:24;;52147:23;52093:24;52147:14;:23::i;:::-;-1:-1:-1;;;;;52138:46:0;;;;;;;;;;;52018:174;;:::o;46637:264::-;46730:4;46747:13;46763:23;46778:7;46763:14;:23::i;:::-;46747:39;;46816:5;-1:-1:-1;;;;;46805:16:0;:7;-1:-1:-1;;;;;46805:16:0;;:52;;;-1:-1:-1;;;;;;43510:25:0;;;43486:4;43510:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;46825:32;46805:87;;;;46885:7;-1:-1:-1;;;;;46861:31:0;:20;46873:7;46861:11;:20::i;:::-;-1:-1:-1;;;;;46861:31:0;;46797:96;46637:264;-1:-1:-1;;;;46637:264:0:o;50636:1263::-;50795:4;-1:-1:-1;;;;;50768:31:0;:23;50783:7;50768:14;:23::i;:::-;-1:-1:-1;;;;;50768:31:0;;50760:81;;;;-1:-1:-1;;;50760:81:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;50860:16:0;;50852:65;;;;-1:-1:-1;;;50852:65:0;;8326:2:1;50852:65:0;;;8308:21:1;8365:2;8345:18;;;8338:30;8404:34;8384:18;;;8377:62;-1:-1:-1;;;8455:18:1;;;8448:34;8499:19;;50852:65:0;8298:226:1;50852:65:0;50930:42;50951:4;50957:2;50961:7;50970:1;50930:20;:42::i;:::-;51102:4;-1:-1:-1;;;;;51075:31:0;:23;51090:7;51075:14;:23::i;:::-;-1:-1:-1;;;;;51075:31:0;;51067:81;;;;-1:-1:-1;;;51067:81:0;;;;;;;:::i;:::-;51220:24;;;;:15;:24;;;;;;;;51213:31;;-1:-1:-1;;;;;;51213:31:0;;;;;;-1:-1:-1;;;;;51696:15:0;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;51696:20:0;;;51731:13;;;;;;;;;:18;;51213:31;51731:18;;;51771:16;;;:7;:16;;;;;;:21;;;;;;;;;;51810:27;;51236:7;;51810:27;;;42438:416;;;:::o;4140:132::-;4048:6;;-1:-1:-1;;;;;4048:6:0;2597:10;4204:23;4196:68;;;;-1:-1:-1;;;4196:68:0;;10271:2:1;4196:68:0;;;10253:21:1;;;10290:18;;;10283:30;10349:34;10329:18;;;10322:62;10401:18;;4196:68:0;10243:182:1;5242:191:0;5335:6;;;-1:-1:-1;;;;;5352:17:0;;;-1:-1:-1;;;;;;5352:17:0;;;;;;;5385:40;;5335:6;;;5352:17;5335:6;;5385:40;;5316:16;;5385:40;5242:191;;:::o;52335:315::-;52490:8;-1:-1:-1;;;;;52481:17:0;:5;-1:-1:-1;;;;;52481:17:0;;;52473:55;;;;-1:-1:-1;;;52473:55:0;;8731:2:1;52473:55:0;;;8713:21:1;8770:2;8750:18;;;8743:30;8809:27;8789:18;;;8782:55;8854:18;;52473:55:0;8703:175:1;52473:55:0;-1:-1:-1;;;;;52539:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;52539:46:0;;;;;;;;;;52601:41;;5845::1;;;52601::0;;5818:18:1;52601:41:0;;;;;;;52335:315;;;:::o;45485:313::-;45641:28;45651:4;45657:2;45661:7;45641:9;:28::i;:::-;45688:47;45711:4;45717:2;45721:7;45730:4;45688:22;:47::i;:::-;45680:110;;;;-1:-1:-1;;;45680:110:0;;;;;;;:::i;41752:281::-;41825:13;41851:23;41866:7;41851:14;:23::i;:::-;41887:21;41911:10;42359:9;;;;;;;;;-1:-1:-1;42359:9:0;;;42282:94;41911:10;41887:34;;41963:1;41945:7;41939:21;:25;:86;;;;;;;;;;;;;;;;;41991:7;42000:18;:7;:16;:18::i;:::-;41974:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;41932:93;41752:281;-1:-1:-1;;;41752:281:0:o;47243:110::-;47319:26;47329:2;47333:7;47319:26;;;;;;;;;;;;:9;:26::i;57940:217::-;46407:4;46005:16;;;:7;:16;;;;;;-1:-1:-1;;;;;46005:16:0;58032:75;;;;-1:-1:-1;;;58032:75:0;;9495:2:1;58032:75:0;;;9477:21:1;9534:2;9514:18;;;9507:30;9573:34;9553:18;;;9546:62;-1:-1:-1;;;9624:18:1;;;9617:44;9678:19;;58032:75:0;9467:236:1;58032:75:0;58118:19;;;;:10;:19;;;;;;;;:31;;;;;;;;:::i;55023:410::-;55213:1;55201:9;:13;55197:229;;;-1:-1:-1;;;;;55235:18:0;;;55231:87;;-1:-1:-1;;;;;55274:15:0;;;;;;:9;:15;;;;;:28;;55293:9;;55274:15;:28;;55293:9;;55274:28;:::i;:::-;;;;-1:-1:-1;;55231:87:0;-1:-1:-1;;;;;55336:16:0;;;55332:83;;-1:-1:-1;;;;;55373:13:0;;;;;;:9;:13;;;;;:26;;55390:9;;55373:13;:26;;55390:9;;55373:26;:::i;:::-;;;;-1:-1:-1;;55023:410:0;;;;:::o;53438:853::-;53592:4;-1:-1:-1;;;;;53613:13:0;;6979:19;:23;53609:675;;53649:71;;-1:-1:-1;;;53649:71:0;;-1:-1:-1;;;;;53649:36:0;;;;;:71;;2597:10;;53700:4;;53706:7;;53715:4;;53649:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53649:71:0;;;;;;;;-1:-1:-1;;53649:71:0;;;;;;;;;;;;:::i;:::-;;;53645:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53890:13:0;;53886:328;;53933:60;;-1:-1:-1;;;53933:60:0;;;;;;;:::i;53886:328::-;54164:6;54158:13;54149:6;54145:2;54141:15;54134:38;53645:584;-1:-1:-1;;;;;;53771:51:0;-1:-1:-1;;;53771:51:0;;-1:-1:-1;53764:58:0;;53609:675;-1:-1:-1;54268:4:0;53438:853;;;;;;:::o;36132:716::-;36188:13;36239:14;36256:17;36267:5;36256:10;:17::i;:::-;36276:1;36256:21;36239:38;;36292:20;36326:6;36315:18;;;;;;-1:-1:-1;;;36315:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;36315:18:0;-1:-1:-1;36292:41:0;-1:-1:-1;36457:28:0;;;36473:2;36457:28;36514:288;-1:-1:-1;;36546:5:0;-1:-1:-1;;;36683:2:0;36672:14;;36667:30;36546:5;36654:44;36744:2;36735:11;;;-1:-1:-1;36769:10:0;36765:21;;36781:5;;36765:21;36514:288;;;-1:-1:-1;36823:6:0;36132:716;-1:-1:-1;;;36132:716:0:o;47580:319::-;47709:18;47715:2;47719:7;47709:5;:18::i;:::-;47760:53;47791:1;47795:2;47799:7;47808:4;47760:22;:53::i;:::-;47738:153;;;;-1:-1:-1;;;47738:153:0;;;;;;;:::i;32989:922::-;33042:7;;-1:-1:-1;;;33120:15:0;;33116:102;;-1:-1:-1;;;33156:15:0;;;-1:-1:-1;33200:2:0;33190:12;33116:102;33245:6;33236:5;:15;33232:102;;33281:6;33272:15;;;-1:-1:-1;33316:2:0;33306:12;33232:102;33361:6;33352:5;:15;33348:102;;33397:6;33388:15;;;-1:-1:-1;33432:2:0;33422:12;33348:102;33477:5;33468;:14;33464:99;;33512:5;33503:14;;;-1:-1:-1;33546:1:0;33536:11;33464:99;33590:5;33581;:14;33577:99;;33625:5;33616:14;;;-1:-1:-1;33659:1:0;33649:11;33577:99;33703:5;33694;:14;33690:99;;33738:5;33729:14;;;-1:-1:-1;33772:1:0;33762:11;33690:99;33816:5;33807;:14;33803:66;;33852:1;33842:11;33897:6;32989:922;-1:-1:-1;;32989:922:0:o;48235:942::-;-1:-1:-1;;;;;48315:16:0;;48307:61;;;;-1:-1:-1;;;48307:61:0;;9910:2:1;48307:61:0;;;9892:21:1;;;9929:18;;;9922:30;9988:34;9968:18;;;9961:62;10040:18;;48307:61:0;9882:182:1;48307:61:0;46407:4;46005:16;;;:7;:16;;;;;;-1:-1:-1;;;;;46005:16:0;46431:31;48379:58;;;;-1:-1:-1;;;48379:58:0;;7969:2:1;48379:58:0;;;7951:21:1;8008:2;7988:18;;;7981:30;8047;8027:18;;;8020:58;8095:18;;48379:58:0;7941:178:1;48379:58:0;48450:48;48479:1;48483:2;48487:7;48496:1;48450:20;:48::i;:::-;46407:4;46005:16;;;:7;:16;;;;;;-1:-1:-1;;;;;46005:16:0;46431:31;48588:58;;;;-1:-1:-1;;;48588:58:0;;7969:2:1;48588:58:0;;;7951:21:1;8008:2;7988:18;;;7981:30;8047;8027:18;;;8020:58;8095:18;;48588:58:0;7941:178:1;48588:58:0;-1:-1:-1;;;;;48995:13:0;;;;;;:9;:13;;;;;;;;:18;;49012:1;48995:18;;;49037:16;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;49037:21:0;;;;;49076:33;49045:7;;48995:13;;49076:33;;48995:13;;49076:33;43163:155;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:631:1;78:5;108:18;149:2;141:6;138:14;135:2;;;155:18;;:::i;:::-;230:2;224:9;198:2;284:15;;-1:-1:-1;;280:24:1;;;306:2;276:33;272:42;260:55;;;330:18;;;350:22;;;327:46;324:2;;;376:18;;:::i;:::-;416:10;412:2;405:22;445:6;436:15;;475:6;467;460:22;515:3;506:6;501:3;497:16;494:25;491:2;;;532:1;529;522:12;491:2;582:6;577:3;570:4;562:6;558:17;545:44;637:1;630:4;621:6;613;609:19;605:30;598:41;;;;88:557;;;;;:::o;650:173::-;718:20;;-1:-1:-1;;;;;767:31:1;;757:42;;747:2;;813:1;810;803:12;747:2;699:124;;;:::o;828:196::-;887:6;940:2;928:9;919:7;915:23;911:32;908:2;;;961:6;953;946:22;908:2;989:29;1008:9;989:29;:::i;1029:270::-;1097:6;1105;1158:2;1146:9;1137:7;1133:23;1129:32;1126:2;;;1179:6;1171;1164:22;1126:2;1207:29;1226:9;1207:29;:::i;:::-;1197:39;;1255:38;1289:2;1278:9;1274:18;1255:38;:::i;:::-;1245:48;;1116:183;;;;;:::o;1304:338::-;1381:6;1389;1397;1450:2;1438:9;1429:7;1425:23;1421:32;1418:2;;;1471:6;1463;1456:22;1418:2;1499:29;1518:9;1499:29;:::i;:::-;1489:39;;1547:38;1581:2;1570:9;1566:18;1547:38;:::i;:::-;1537:48;;1632:2;1621:9;1617:18;1604:32;1594:42;;1408:234;;;;;:::o;1647:696::-;1742:6;1750;1758;1766;1819:3;1807:9;1798:7;1794:23;1790:33;1787:2;;;1841:6;1833;1826:22;1787:2;1869:29;1888:9;1869:29;:::i;:::-;1859:39;;1917:38;1951:2;1940:9;1936:18;1917:38;:::i;:::-;1907:48;;2002:2;1991:9;1987:18;1974:32;1964:42;;2057:2;2046:9;2042:18;2029:32;2084:18;2076:6;2073:30;2070:2;;;2121:6;2113;2106:22;2070:2;2149:22;;2202:4;2194:13;;2190:27;-1:-1:-1;2180:2:1;;2236:6;2228;2221:22;2180:2;2264:73;2329:7;2324:2;2311:16;2306:2;2302;2298:11;2264:73;:::i;:::-;2254:83;;;1777:566;;;;;;;:::o;2348:367::-;2413:6;2421;2474:2;2462:9;2453:7;2449:23;2445:32;2442:2;;;2495:6;2487;2480:22;2442:2;2523:29;2542:9;2523:29;:::i;:::-;2513:39;;2602:2;2591:9;2587:18;2574:32;2649:5;2642:13;2635:21;2628:5;2625:32;2615:2;;2676:6;2668;2661:22;2615:2;2704:5;2694:15;;;2432:283;;;;;:::o;2720:554::-;2798:6;2806;2859:2;2847:9;2838:7;2834:23;2830:32;2827:2;;;2880:6;2872;2865:22;2827:2;2908:29;2927:9;2908:29;:::i;:::-;2898:39;;2988:2;2977:9;2973:18;2960:32;3015:18;3007:6;3004:30;3001:2;;;3052:6;3044;3037:22;3001:2;3080:22;;3133:4;3125:13;;3121:27;-1:-1:-1;3111:2:1;;3167:6;3159;3152:22;3111:2;3195:73;3260:7;3255:2;3242:16;3237:2;3233;3229:11;3195:73;:::i;:::-;3185:83;;;2817:457;;;;;:::o;3279:264::-;3347:6;3355;3408:2;3396:9;3387:7;3383:23;3379:32;3376:2;;;3429:6;3421;3414:22;3376:2;3457:29;3476:9;3457:29;:::i;:::-;3447:39;3533:2;3518:18;;;;3505:32;;-1:-1:-1;;;3366:177:1:o;3548:255::-;3606:6;3659:2;3647:9;3638:7;3634:23;3630:32;3627:2;;;3680:6;3672;3665:22;3627:2;3724:9;3711:23;3743:30;3767:5;3743:30;:::i;3808:259::-;3877:6;3930:2;3918:9;3909:7;3905:23;3901:32;3898:2;;;3951:6;3943;3936:22;3898:2;3988:9;3982:16;4007:30;4031:5;4007:30;:::i;4072:190::-;4131:6;4184:2;4172:9;4163:7;4159:23;4155:32;4152:2;;;4205:6;4197;4190:22;4152:2;-1:-1:-1;4233:23:1;;4142:120;-1:-1:-1;4142:120:1:o;4267:257::-;4308:3;4346:5;4340:12;4373:6;4368:3;4361:19;4389:63;4445:6;4438:4;4433:3;4429:14;4422:4;4415:5;4411:16;4389:63;:::i;:::-;4506:2;4485:15;-1:-1:-1;;4481:29:1;4472:39;;;;4513:4;4468:50;;4316:208;-1:-1:-1;;4316:208:1:o;4529:470::-;4708:3;4746:6;4740:13;4762:53;4808:6;4803:3;4796:4;4788:6;4784:17;4762:53;:::i;:::-;4878:13;;4837:16;;;;4900:57;4878:13;4837:16;4934:4;4922:17;;4900:57;:::i;:::-;4973:20;;4716:283;-1:-1:-1;;;;4716:283:1:o;5212:488::-;-1:-1:-1;;;;;5481:15:1;;;5463:34;;5533:15;;5528:2;5513:18;;5506:43;5580:2;5565:18;;5558:34;;;5628:3;5623:2;5608:18;;5601:31;;;5406:4;;5649:45;;5674:19;;5666:6;5649:45;:::i;:::-;5641:53;5415:285;-1:-1:-1;;;;;;5415:285:1:o;5897:219::-;6046:2;6035:9;6028:21;6009:4;6066:44;6106:2;6095:9;6091:18;6083:6;6066:44;:::i;6121:409::-;6323:2;6305:21;;;6362:2;6342:18;;;6335:30;6401:34;6396:2;6381:18;;6374:62;-1:-1:-1;;;6467:2:1;6452:18;;6445:43;6520:3;6505:19;;6295:235::o;6535:414::-;6737:2;6719:21;;;6776:2;6756:18;;;6749:30;6815:34;6810:2;6795:18;;6788:62;-1:-1:-1;;;6881:2:1;6866:18;;6859:48;6939:3;6924:19;;6709:240::o;7361:401::-;7563:2;7545:21;;;7602:2;7582:18;;;7575:30;7641:34;7636:2;7621:18;;7614:62;-1:-1:-1;;;7707:2:1;7692:18;;7685:35;7752:3;7737:19;;7535:227::o;11797:128::-;11837:3;11868:1;11864:6;11861:1;11858:13;11855:2;;;11874:18;;:::i;:::-;-1:-1:-1;11910:9:1;;11845:80::o;11930:125::-;11970:4;11998:1;11995;11992:8;11989:2;;;12003:18;;:::i;:::-;-1:-1:-1;12040:9:1;;11979:76::o;12060:258::-;12132:1;12142:113;12156:6;12153:1;12150:13;12142:113;;;12232:11;;;12226:18;12213:11;;;12206:39;12178:2;12171:10;12142:113;;;12273:6;12270:1;12267:13;12264:2;;;-1:-1:-1;;12308:1:1;12290:16;;12283:27;12113:205::o;12323:380::-;12402:1;12398:12;;;;12445;;;12466:2;;12520:4;12512:6;12508:17;12498:27;;12466:2;12573;12565:6;12562:14;12542:18;12539:38;12536:2;;;12619:10;12614:3;12610:20;12607:1;12600:31;12654:4;12651:1;12644:15;12682:4;12679:1;12672:15;12536:2;;12378:325;;;:::o;12708:127::-;12769:10;12764:3;12760:20;12757:1;12750:31;12800:4;12797:1;12790:15;12824:4;12821:1;12814:15;12840:127;12901:10;12896:3;12892:20;12889:1;12882:31;12932:4;12929:1;12922:15;12956:4;12953:1;12946:15;12972:131;-1:-1:-1;;;;;;13046:32:1;;13036:43;;13026:2;;13093:1;13090;13083:12

Swarm Source

ipfs://afe6cfe488b623b75197a169bf2c93f1220e5b8e30d7a63717de7ee5f45d7bed
Loading