BraveBears (BB) Token Tracker

BraveBears (BB)

Overview

TokenID

109

Total Transfers

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract

0x9f91717cd794f3b7a7b5e2ddfaa6723f19e24134

TokenID: 109

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

BraveBears

Compiler Version

v0.8.13+commit.abaa5c0e

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-04-16
*/

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: @openzeppelin/contracts/utils/Strings.sol


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

pragma solidity ^0.8.0;

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

// File: @openzeppelin/contracts/utils/Context.sol


// 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/Ownable.sol


// OpenZeppelin Contracts v4.4.1 (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 Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

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

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

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

// File: @openzeppelin/contracts/utils/Address.sol


// OpenZeppelin Contracts (last updated v4.5.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 functionCall(target, data, "Address: low-level call failed");
    }

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;



/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: @openzeppelin/contracts/finance/PaymentSplitter.sol


// OpenZeppelin Contracts v4.4.1 (finance/PaymentSplitter.sol)

pragma solidity ^0.8.0;




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

    uint256 private _totalShares;
    uint256 private _totalReleased;

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

    mapping(IERC20 => uint256) private _erc20TotalReleased;
    mapping(IERC20 => mapping(address => uint256)) private _erc20Released;

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

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

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

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

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

    /**
     * @dev Getter for the total amount of `token` already released. `token` should be the address of an IERC20
     * contract.
     */
    function totalReleased(IERC20 token) public view returns (uint256) {
        return _erc20TotalReleased[token];
    }

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

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

    /**
     * @dev Getter for the amount of `token` tokens already released to a payee. `token` should be the address of an
     * IERC20 contract.
     */
    function released(IERC20 token, address account) public view returns (uint256) {
        return _erc20Released[token][account];
    }

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

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

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

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

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

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

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

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

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

        _erc20Released[token][account] += payment;
        _erc20TotalReleased[token] += payment;

        SafeERC20.safeTransfer(token, account, payment);
        emit ERC20PaymentReleased(token, account, payment);
    }

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

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

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

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// 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/utils/introspection/ERC165.sol


// 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/IERC721.sol


// OpenZeppelin Contracts v4.4.1 (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`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol


// 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: erc721a/contracts/ERC721A.sol


// Creator: Chiru Labs

pragma solidity ^0.8.4;








error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();

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

    // Compiler will pack this into a single 256bit word.
    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Keeps track of the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
    }

    // Compiler will pack this into a single 256bit word.
    struct AddressData {
        // Realistically, 2**64-1 is more than enough.
        uint64 balance;
        // Keeps track of mint count with minimal overhead for tokenomics.
        uint64 numberMinted;
        // Keeps track of burn count with minimal overhead for tokenomics.
        uint64 numberBurned;
        // For miscellaneous variable(s) pertaining to the address
        // (e.g. number of whitelist mint slots used).
        // If there are multiple variables, please pack them into a uint64.
        uint64 aux;
    }

    // The tokenId of the next token to be minted.
    uint256 internal _currentIndex;

    // The number of tokens burned.
    uint256 internal _burnCounter;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to ownership details
    // An empty struct value does not necessarily mean the token is unowned. See _ownershipOf implementation for details.
    mapping(uint256 => TokenOwnership) internal _ownerships;

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

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

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

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
        _currentIndex = _startTokenId();
    }

    /**
     * To change the starting tokenId, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 0;
    }

    /**
     * @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
     */
    function totalSupply() public view returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than _currentIndex - _startTokenId() times
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

    /**
     * Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view returns (uint256) {
        // Counter underflow is impossible as _currentIndex does not decrement,
        // and it is initialized to _startTokenId()
        unchecked {
            return _currentIndex - _startTokenId();
        }
    }

    /**
     * @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 override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return uint256(_addressData[owner].balance);
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberMinted);
    }

    /**
     * Returns the number of tokens burned by or on behalf of `owner`.
     */
    function _numberBurned(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberBurned);
    }

    /**
     * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     */
    function _getAux(address owner) internal view returns (uint64) {
        return _addressData[owner].aux;
    }

    /**
     * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal {
        _addressData[owner].aux = aux;
    }

    /**
     * Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around in the collection over time.
     */
    function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr && curr < _currentIndex) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (!ownership.burned) {
                    if (ownership.addr != address(0)) {
                        return ownership;
                    }
                    // Invariant:
                    // There will always be an ownership that has an address and is not burned
                    // before an ownership that does not have an address and is not burned.
                    // Hence, curr will not underflow.
                    while (true) {
                        curr--;
                        ownership = _ownerships[curr];
                        if (ownership.addr != address(0)) {
                            return ownership;
                        }
                    }
                }
            }
        }
        revert OwnerQueryForNonexistentToken();
    }

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

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

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

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

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return '';
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public override {
        address owner = ERC721A.ownerOf(tokenId);
        if (to == owner) revert ApprovalToCurrentOwner();

        if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
            revert ApprovalCallerNotOwnerNorApproved();
        }

        _approve(to, tokenId, owner);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        if (operator == _msgSender()) revert ApproveToCaller();

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        _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 {
        _transfer(from, to, tokenId);
        if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
            revert TransferToNonERC721ReceiverImplementer();
        }
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        return _startTokenId() <= tokenId && tokenId < _currentIndex && !_ownerships[tokenId].burned;
    }

    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, '');
    }

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        _mint(to, quantity, _data, true);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _mint(
        address to,
        uint256 quantity,
        bytes memory _data,
        bool safe
    ) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

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

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint64(quantity);
            _addressData[to].numberMinted += uint64(quantity);

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

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            if (safe && to.isContract()) {
                do {
                    emit Transfer(address(0), to, updatedIndex);
                    if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (updatedIndex != end);
                // Reentrancy protection
                if (_currentIndex != startTokenId) revert();
            } else {
                do {
                    emit Transfer(address(0), to, updatedIndex++);
                } while (updatedIndex != end);
            }
            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) private {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();

        bool isApprovedOrOwner = (_msgSender() == from ||
            isApprovedForAll(from, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

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

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            _addressData[from].balance -= 1;
            _addressData[to].balance += 1;

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

            // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

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

    /**
     * @dev This is equivalent to _burn(tokenId, false)
     */
    function _burn(uint256 tokenId) internal virtual {
        _burn(tokenId, false);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        address from = prevOwnership.addr;

        if (approvalCheck) {
            bool isApprovedOrOwner = (_msgSender() == from ||
                isApprovedForAll(from, _msgSender()) ||
                getApproved(tokenId) == _msgSender());

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

        _beforeTokenTransfers(from, address(0), tokenId, 1);

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

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            AddressData storage addressData = _addressData[from];
            addressData.balance -= 1;
            addressData.numberBurned += 1;

            // Keep track of who burned the token, and the timestamp of burning.
            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = from;
            currSlot.startTimestamp = uint64(block.timestamp);
            currSlot.burned = true;

            // If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, address(0), tokenId);
        _afterTokenTransfers(from, address(0), tokenId, 1);

        // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
        unchecked {
            _burnCounter++;
        }
    }

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

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target 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 _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
            return retval == IERC721Receiver(to).onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == 0) {
                revert TransferToNonERC721ReceiverImplementer();
            } else {
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     * And also called before burning one token.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
     * minting.
     * And also called after one token has been burned.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
     * transferred to `to`.
     * - When `from` is zero, `tokenId` has been minted for `to`.
     * - When `to` is zero, `tokenId` has been burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}

// File: contracts/BraveBears.sol



pragma solidity ^0.8.13;




contract BraveBears is ERC721A, Ownable, PaymentSplitter {
    using Strings for uint256;

    string private baseURI;
    string private constant tokenName = "BraveBears";
    string private constant tokenSymbol = "BB";

    bool public didOwnerMint;
    bool public isRevealed;
    bool public isSaleActive;

    uint256 public maxPerTx = 5;
    uint256 public salePrice = 0.0055 ether;
    uint256 public maxSupply = 999;

    address[] private _teamPayees = [
        0x157d27dF367E8ca92718B2f78A46b6B370828D09,
        0x1A030976fE1758bF9aF70D387A7B9DE445c1ECce,
        0xe270c26e1aafc57Cf20E92eE7Af35b34c4FEe900,
        0x1821710C2E3b1B436f804E147aBB5f7dFf99D3b5
    ];

    uint256[] private _teamShares = [25, 25, 25, 25];

    constructor()
        ERC721A(tokenName, tokenSymbol)
        PaymentSplitter(_teamPayees, _teamShares)
    {}

    function mint(uint256 _amount) external payable {
        require(isSaleActive, "Sale not active");
        require(_amount <= maxPerTx, "Can not exceed max mint amount");
        require(msg.value >= _amount * salePrice, "Insufficient Ether sent");
        require(totalSupply() + _amount <= maxSupply, "Not enough supply");
        _safeMint(msg.sender, _amount);
    }

    function ownerMint() external onlyOwner {
        require(!didOwnerMint, "Already minted");
        require(totalSupply() + 10 <= maxSupply, "Not enough supply");
        _safeMint(msg.sender, 10);
        didOwnerMint = true;
    }

    function cutMaxSupply(uint256 _maxSupply) external onlyOwner {
        require(_maxSupply < maxSupply, "Can not increase maxSupply");
        require(
            _maxSupply > totalSupply(),
            "Can not be lower than total supply"
        );
        maxSupply = _maxSupply;
    }

    function reveal(string memory _baseURI) external onlyOwner {
        baseURI = _baseURI;
        isRevealed = true;
    }

    function toggleSale() external onlyOwner {
        isSaleActive = !isSaleActive;
    }

    function tokenURI(uint256 _tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        require(_exists(_tokenId), "Token does not exist");
        if (isRevealed) {
            return
                string(abi.encodePacked(baseURI, _tokenId.toString(), ".json"));
        } else {
            return string(abi.encodePacked(baseURI));
        }
    }

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

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"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":"contract IERC20","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC20PaymentReleased","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":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"PayeeAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReleased","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":"_maxSupply","type":"uint256"}],"name":"cutMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"didOwnerMint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"isRevealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isSaleActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ownerMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"payee","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseURI","type":"string"}],"name":"reveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"salePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"shares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toggleSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

59267:2576:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24166:40;5762:10;24166:40;;;-1:-1:-1;;;;;206:32:1;;;188:51;;24196:9:0;270:2:1;255:18;;248:34;161:18;24166:40:0;;;;;;;59267:2576;;;;;41447:305;;;;;;;;;;-1:-1:-1;41447:305:0;;;;;:::i;:::-;;:::i;:::-;;;844:14:1;;837:22;819:41;;807:2;792:18;41447:305:0;;;;;;;;44560:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;46063:204::-;;;;;;;;;;-1:-1:-1;46063:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1971:32:1;;;1953:51;;1941:2;1926:18;46063:204:0;1807:203:1;45626:371:0;;;;;;;;;;-1:-1:-1;45626:371:0;;;;;:::i;:::-;;:::i;:::-;;60780:295;;;;;;;;;;-1:-1:-1;60780:295:0;;;;;:::i;:::-;;:::i;40696:303::-;;;;;;;;;;-1:-1:-1;40950:12:0;;40740:7;40934:13;:28;40696:303;;;2617:25:1;;;2605:2;2590:18;40696:303:0;2471:177:1;25952:566:0;;;;;;;;;;-1:-1:-1;25952:566:0;;;;;:::i;:::-;;:::i;46928:170::-;;;;;;;;;;-1:-1:-1;46928:170:0;;;;;:::i;:::-;;:::i;24297:91::-;;;;;;;;;;-1:-1:-1;24368:12:0;;24297:91;;25426:135;;;;;;;;;;-1:-1:-1;25426:135:0;;;;;:::i;:::-;-1:-1:-1;;;;;25523:21:0;;;25496:7;25523:21;;;:14;:21;;;;;;;;:30;;;;;;;;;;;;;25426:135;47169:185;;;;;;;;;;-1:-1:-1;47169:185:0;;;;;:::i;:::-;;:::i;26786:641::-;;;;;;;;;;-1:-1:-1;26786:641:0;;;;;:::i;:::-;;:::i;61083:124::-;;;;;;;;;;-1:-1:-1;61083:124:0;;;;;:::i;:::-;;:::i;59531:22::-;;;;;;;;;;-1:-1:-1;59531:22:0;;;;;;;;;;;61740:100;;;;;;;;;;-1:-1:-1;61740:100:0;;;;;:::i;:::-;;:::i;59560:24::-;;;;;;;;;;-1:-1:-1;59560:24:0;;;;;;;;;;;59500;;;;;;;;;;-1:-1:-1;59500:24:0;;;;;;;;44368:125;;;;;;;;;;-1:-1:-1;44368:125:0;;;;;:::i;:::-;;:::i;41816:206::-;;;;;;;;;;-1:-1:-1;41816:206:0;;;;;:::i;:::-;;:::i;7609:103::-;;;;;;;;;;;;;:::i;61215:88::-;;;;;;;;;;;;;:::i;25652:100::-;;;;;;;;;;-1:-1:-1;25652:100:0;;;;;:::i;:::-;;:::i;6958:87::-;;;;;;;;;;-1:-1:-1;7031:6:0;;-1:-1:-1;;;;;7031:6:0;6958:87;;44729:104;;;;;;;;;;;;;:::i;25148:109::-;;;;;;;;;;-1:-1:-1;25148:109:0;;;;;:::i;:::-;-1:-1:-1;;;;;25231:18:0;25204:7;25231:18;;;:9;:18;;;;;;;25148:109;60150:377;;;;;;:::i;:::-;;:::i;46339:287::-;;;;;;;;;;-1:-1:-1;46339:287:0;;;;;:::i;:::-;;:::i;60535:237::-;;;;;;;;;;;;;:::i;47425:369::-;;;;;;;;;;-1:-1:-1;47425:369:0;;;;;:::i;:::-;;:::i;61311:421::-;;;;;;;;;;-1:-1:-1;61311:421:0;;;;;:::i;:::-;;:::i;24944:105::-;;;;;;;;;;-1:-1:-1;24944:105:0;;;;;:::i;:::-;-1:-1:-1;;;;;25025:16:0;24998:7;25025:16;;;:7;:16;;;;;;;24944:105;59673:30;;;;;;;;;;;;;;;;24734:119;;;;;;;;;;-1:-1:-1;24734:119:0;;;;;:::i;:::-;-1:-1:-1;;;;;24819:26:0;24792:7;24819:26;;;:19;:26;;;;;;;24734:119;24482:95;;;;;;;;;;-1:-1:-1;24555:14:0;;24482:95;;46697:164;;;;;;;;;;-1:-1:-1;46697:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;46818:25:0;;;46794:4;46818:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;46697:164;7867:201;;;;;;;;;;-1:-1:-1;7867:201:0;;;;;:::i;:::-;;:::i;59627:39::-;;;;;;;;;;;;;;;;59593:27;;;;;;;;;;;;;;;;41447:305;41549:4;-1:-1:-1;;;;;;41586:40:0;;-1:-1:-1;;;41586:40:0;;:105;;-1:-1:-1;;;;;;;41643:48:0;;-1:-1:-1;;;41643:48:0;41586:105;:158;;;-1:-1:-1;;;;;;;;;;31447:40:0;;;41708:36;41566:178;41447:305;-1:-1:-1;;41447:305:0:o;44560:100::-;44614:13;44647:5;44640:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44560:100;:::o;46063:204::-;46131:7;46156:16;46164:7;46156;:16::i;:::-;46151:64;;46181:34;;-1:-1:-1;;;46181:34:0;;;;;;;;;;;46151:64;-1:-1:-1;46235:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;46235:24:0;;46063:204::o;45626:371::-;45699:13;45715:24;45731:7;45715:15;:24::i;:::-;45699:40;;45760:5;-1:-1:-1;;;;;45754:11:0;:2;-1:-1:-1;;;;;45754:11:0;;45750:48;;45774:24;;-1:-1:-1;;;45774:24:0;;;;;;;;;;;45750:48;5762:10;-1:-1:-1;;;;;45815:21:0;;;;;;:63;;-1:-1:-1;45841:37:0;45858:5;5762:10;46697:164;:::i;45841:37::-;45840:38;45815:63;45811:138;;;45902:35;;-1:-1:-1;;;45902:35:0;;;;;;;;;;;45811:138;45961:28;45970:2;45974:7;45983:5;45961:8;:28::i;:::-;45688:309;45626:371;;:::o;60780:295::-;7031:6;;-1:-1:-1;;;;;7031:6:0;5762:10;7178:23;7170:68;;;;-1:-1:-1;;;7170:68:0;;;;;;;:::i;:::-;;;;;;;;;60873:9:::1;;60860:10;:22;60852:61;;;::::0;-1:-1:-1;;;60852:61:0;;8173:2:1;60852:61:0::1;::::0;::::1;8155:21:1::0;8212:2;8192:18;;;8185:30;8251:28;8231:18;;;8224:56;8297:18;;60852:61:0::1;7971:350:1::0;60852:61:0::1;40950:12:::0;;40740:7;40934:13;:28;60946:10:::1;:26;60924:110;;;::::0;-1:-1:-1;;;60924:110:0;;8528:2:1;60924:110:0::1;::::0;::::1;8510:21:1::0;8567:2;8547:18;;;8540:30;8606:34;8586:18;;;8579:62;-1:-1:-1;;;8657:18:1;;;8650:32;8699:19;;60924:110:0::1;8326:398:1::0;60924:110:0::1;61045:9;:22:::0;60780:295::o;25952:566::-;-1:-1:-1;;;;;26028:16:0;;26047:1;26028:16;;;:7;:16;;;;;;26020:71;;;;-1:-1:-1;;;26020:71:0;;;;;;;:::i;:::-;26104:21;26152:15;24555:14;;;24482:95;26152:15;26128:39;;:21;:39;:::i;:::-;26104:63;;26178:15;26196:58;26212:7;26221:13;26236:17;26245:7;-1:-1:-1;;;;;25231:18:0;25204:7;25231:18;;;:9;:18;;;;;;;25148:109;26236:17;26196:15;:58::i;:::-;26178:76;;26275:7;26286:1;26275:12;26267:68;;;;-1:-1:-1;;;26267:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;26348:18:0;;;;;;:9;:18;;;;;:29;;26370:7;;26348:18;:29;;26370:7;;26348:29;:::i;:::-;;;;;;;;26406:7;26388:14;;:25;;;;;;;:::i;:::-;;;;-1:-1:-1;26426:35:0;;-1:-1:-1;26444:7:0;26453;26426:17;:35::i;:::-;26477:33;;;-1:-1:-1;;;;;206:32:1;;188:51;;270:2;255:18;;248:34;;;26477:33:0;;161:18:1;26477:33:0;;;;;;;26009:509;;25952:566;:::o;46928:170::-;47062:28;47072:4;47078:2;47082:7;47062:9;:28::i;47169:185::-;47307:39;47324:4;47330:2;47334:7;47307:39;;;;;;;;;;;;:16;:39::i;26786:641::-;-1:-1:-1;;;;;26868:16:0;;26887:1;26868:16;;;:7;:16;;;;;;26860:71;;;;-1:-1:-1;;;26860:71:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;24819:26:0;;26944:21;24819:26;;;:19;:26;;;;;;26968:30;;-1:-1:-1;;;26968:30:0;;26992:4;26968:30;;;1953:51:1;-1:-1:-1;;;;;26968:15:0;;;;;1926:18:1;;26968:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:53;;;;:::i;:::-;26944:77;;27032:15;27050:65;27066:7;27075:13;27090:24;27099:5;27106:7;-1:-1:-1;;;;;25523:21:0;;;25496:7;25523:21;;;:14;:21;;;;;;;;:30;;;;;;;;;;;;;25426:135;27050:65;27032:83;;27136:7;27147:1;27136:12;27128:68;;;;-1:-1:-1;;;27128:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;27209:21:0;;;;;;;:14;:21;;;;;;;;:30;;;;;;;;;;;:41;;27243:7;;27209:21;:41;;27243:7;;27209:41;:::i;:::-;;;;-1:-1:-1;;;;;;;27261:26:0;;;;;;:19;:26;;;;;:37;;27291:7;;27261:26;:37;;27291:7;;27261:37;:::i;:::-;;;;-1:-1:-1;27311:47:0;;-1:-1:-1;27334:5:0;27341:7;27350;27311:22;:47::i;:::-;27374:45;;;-1:-1:-1;;;;;206:32:1;;;188:51;;270:2;255:18;;248:34;;;27374:45:0;;;;;161:18:1;27374:45:0;;;;;;;26849:578;;26786:641;;:::o;61083:124::-;7031:6;;-1:-1:-1;;;;;7031:6:0;5762:10;7178:23;7170:68;;;;-1:-1:-1;;;7170:68:0;;;;;;;:::i;:::-;61153:18;;::::1;::::0;:7:::1;::::0;:18:::1;::::0;::::1;::::0;::::1;:::i;:::-;-1:-1:-1::0;;61182:10:0::1;:17:::0;;-1:-1:-1;;61182:17:0::1;;;::::0;;61083:124::o;61740:100::-;7031:6;;-1:-1:-1;;;;;7031:6:0;5762:10;7178:23;7170:68;;;;-1:-1:-1;;;7170:68:0;;;;;;;:::i;:::-;61814:18;;::::1;::::0;:7:::1;::::0;:18:::1;::::0;::::1;::::0;::::1;:::i;:::-;;61740:100:::0;:::o;44368:125::-;44432:7;44459:21;44472:7;44459:12;:21::i;:::-;:26;;44368:125;-1:-1:-1;;44368:125:0:o;41816:206::-;41880:7;-1:-1:-1;;;;;41904:19:0;;41900:60;;41932:28;;-1:-1:-1;;;41932:28:0;;;;;;;;;;;41900:60;-1:-1:-1;;;;;;41986:19:0;;;;;:12;:19;;;;;:27;;;;41816:206::o;7609:103::-;7031:6;;-1:-1:-1;;;;;7031:6:0;5762:10;7178:23;7170:68;;;;-1:-1:-1;;;7170:68:0;;;;;;;:::i;:::-;7674:30:::1;7701:1;7674:18;:30::i;:::-;7609:103::o:0;61215:88::-;7031:6;;-1:-1:-1;;;;;7031:6:0;5762:10;7178:23;7170:68;;;;-1:-1:-1;;;7170:68:0;;;;;;;:::i;:::-;61283:12:::1;::::0;;-1:-1:-1;;61267:28:0;::::1;61283:12:::0;;;;::::1;;;61282:13;61267:28:::0;;::::1;;::::0;;61215:88::o;25652:100::-;25703:7;25730;25738:5;25730:14;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;25730:14:0;;25652:100;-1:-1:-1;;25652:100:0:o;44729:104::-;44785:13;44818:7;44811:14;;;;;:::i;60150:377::-;60217:12;;;;;;;60209:40;;;;-1:-1:-1;;;60209:40:0;;10623:2:1;60209:40:0;;;10605:21:1;10662:2;10642:18;;;10635:30;-1:-1:-1;;;10681:18:1;;;10674:45;10736:18;;60209:40:0;10421:339:1;60209:40:0;60279:8;;60268:7;:19;;60260:62;;;;-1:-1:-1;;;60260:62:0;;10967:2:1;60260:62:0;;;10949:21:1;11006:2;10986:18;;;10979:30;11045:32;11025:18;;;11018:60;11095:18;;60260:62:0;10765:354:1;60260:62:0;60364:9;;60354:19;;:7;:19;:::i;:::-;60341:9;:32;;60333:68;;;;-1:-1:-1;;;60333:68:0;;11499:2:1;60333:68:0;;;11481:21:1;11538:2;11518:18;;;11511:30;11577:25;11557:18;;;11550:53;11620:18;;60333:68:0;11297:347:1;60333:68:0;60447:9;;60436:7;60420:13;40950:12;;40740:7;40934:13;:28;;40696:303;60420:13;:23;;;;:::i;:::-;:36;;60412:66;;;;-1:-1:-1;;;60412:66:0;;11851:2:1;60412:66:0;;;11833:21:1;11890:2;11870:18;;;11863:30;-1:-1:-1;;;11909:18:1;;;11902:47;11966:18;;60412:66:0;11649:341:1;60412:66:0;60489:30;60499:10;60511:7;60489:9;:30::i;:::-;60150:377;:::o;46339:287::-;5762:10;-1:-1:-1;;;;;46438:24:0;;;46434:54;;46471:17;;-1:-1:-1;;;46471:17:0;;;;;;;;;;;46434:54;5762:10;46501:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;46501:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;46501:53:0;;;;;;;;;;46570:48;;819:41:1;;;46501:42:0;;5762:10;46570:48;;792:18:1;46570:48:0;;;;;;;46339:287;;:::o;60535:237::-;7031:6;;-1:-1:-1;;;;;7031:6:0;5762:10;7178:23;7170:68;;;;-1:-1:-1;;;7170:68:0;;;;;;;:::i;:::-;60595:12:::1;::::0;::::1;;60594:13;60586:40;;;::::0;-1:-1:-1;;;60586:40:0;;12197:2:1;60586:40:0::1;::::0;::::1;12179:21:1::0;12236:2;12216:18;;;12209:30;-1:-1:-1;;;12255:18:1;;;12248:44;12309:18;;60586:40:0::1;11995:338:1::0;60586:40:0::1;60667:9;::::0;40950:12;;40740:7;40934:13;:28;60645:18:::1;::::0;60661:2:::1;60645:18;:::i;:::-;:31;;60637:61;;;::::0;-1:-1:-1;;;60637:61:0;;11851:2:1;60637:61:0::1;::::0;::::1;11833:21:1::0;11890:2;11870:18;;;11863:30;-1:-1:-1;;;11909:18:1;;;11902:47;11966:18;;60637:61:0::1;11649:341:1::0;60637:61:0::1;60709:25;60719:10;60731:2;60709:9;:25::i;:::-;60745:12;:19:::0;;-1:-1:-1;;60745:19:0::1;60760:4;60745:19;::::0;;60535:237::o;47425:369::-;47592:28;47602:4;47608:2;47612:7;47592:9;:28::i;:::-;-1:-1:-1;;;;;47635:13:0;;9954:19;:23;;47635:76;;;;;47655:56;47686:4;47692:2;47696:7;47705:5;47655:30;:56::i;:::-;47654:57;47635:76;47631:156;;;47735:40;;-1:-1:-1;;;47735:40:0;;;;;;;;;;;47631:156;47425:369;;;;:::o;61311:421::-;61430:13;61469:17;61477:8;61469:7;:17::i;:::-;61461:50;;;;-1:-1:-1;;;61461:50:0;;12540:2:1;61461:50:0;;;12522:21:1;12579:2;12559:18;;;12552:30;-1:-1:-1;;;12598:18:1;;;12591:50;12658:18;;61461:50:0;12338:344:1;61461:50:0;61526:10;;;;;;;61522:203;;;61601:7;61610:19;:8;:17;:19::i;:::-;61584:55;;;;;;;;;:::i;:::-;;;;;;;;;;;;;61553:87;;61311:421;;;:::o;61522:203::-;61704:7;61687:25;;;;;;;;:::i;7867:201::-;7031:6;;-1:-1:-1;;;;;7031:6:0;5762:10;7178:23;7170:68;;;;-1:-1:-1;;;7170:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;7956:22:0;::::1;7948:73;;;::::0;-1:-1:-1;;;7948:73:0;;14743:2:1;7948:73:0::1;::::0;::::1;14725:21:1::0;14782:2;14762:18;;;14755:30;14821:34;14801:18;;;14794:62;-1:-1:-1;;;14872:18:1;;;14865:36;14918:19;;7948:73:0::1;14541:402:1::0;7948:73:0::1;8032:28;8051:8;8032:18;:28::i;48049:174::-:0;48106:4;48170:13;;48160:7;:23;48130:85;;;;-1:-1:-1;;48188:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;48188:27:0;;;;48187:28;;48049:174::o;56206:196::-;56321:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;56321:29:0;-1:-1:-1;;;;;56321:29:0;;;;;;;;;56366:28;;56321:24;;56366:28;;;;;;;56206:196;;;:::o;27605:248::-;27815:12;;-1:-1:-1;;;;;27795:16:0;;27751:7;27795:16;;;:7;:16;;;;;;27751:7;;27830:15;;27779:32;;:13;:32;:::i;:::-;27778:49;;;;:::i;:::-;:67;;;;:::i;:::-;27771:74;;27605:248;;;;;;:::o;10920:317::-;11035:6;11010:21;:31;;11002:73;;;;-1:-1:-1;;;11002:73:0;;15537:2:1;11002:73:0;;;15519:21:1;15576:2;15556:18;;;15549:30;15615:31;15595:18;;;15588:59;15664:18;;11002:73:0;15335:353:1;11002:73:0;11089:12;11107:9;-1:-1:-1;;;;;11107:14:0;11129:6;11107:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11088:52;;;11159:7;11151:78;;;;-1:-1:-1;;;11151:78:0;;16105:2:1;11151:78:0;;;16087:21:1;16144:2;16124:18;;;16117:30;16183:34;16163:18;;;16156:62;16254:28;16234:18;;;16227:56;16300:19;;11151:78:0;15903:422:1;51149:2130:0;51264:35;51302:21;51315:7;51302:12;:21::i;:::-;51264:59;;51362:4;-1:-1:-1;;;;;51340:26:0;:13;:18;;;-1:-1:-1;;;;;51340:26:0;;51336:67;;51375:28;;-1:-1:-1;;;51375:28:0;;;;;;;;;;;51336:67;51416:22;5762:10;-1:-1:-1;;;;;51442:20:0;;;;:73;;-1:-1:-1;51479:36:0;51496:4;5762:10;46697:164;:::i;51479:36::-;51442:126;;;-1:-1:-1;5762:10:0;51532:20;51544:7;51532:11;:20::i;:::-;-1:-1:-1;;;;;51532:36:0;;51442:126;51416:153;;51587:17;51582:66;;51613:35;;-1:-1:-1;;;51613:35:0;;;;;;;;;;;51582:66;-1:-1:-1;;;;;51663:16:0;;51659:52;;51688:23;;-1:-1:-1;;;51688:23:0;;;;;;;;;;;51659:52;51832:35;51849:1;51853:7;51862:4;51832:8;:35::i;:::-;-1:-1:-1;;;;;52163:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;52163:31:0;;;;;;;-1:-1:-1;;52163:31:0;;;;;;;52209:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;52209:29:0;;;;;;;;;;;52289:20;;;:11;:20;;;;;;52324:18;;-1:-1:-1;;;;;;52357:49:0;;;;-1:-1:-1;;;52390:15:0;52357:49;;;;;;;;;;52680:11;;52740:24;;;;;52783:13;;52289:20;;52740:24;;52783:13;52779:384;;52993:13;;52978:11;:28;52974:174;;53031:20;;53100:28;;;;53074:54;;-1:-1:-1;;;53074:54:0;-1:-1:-1;;;;;;53074:54:0;;;-1:-1:-1;;;;;53031:20:0;;53074:54;;;;52974:174;52138:1036;;;53210:7;53206:2;-1:-1:-1;;;;;53191:27:0;53200:4;-1:-1:-1;;;;;53191:27:0;;;;;;;;;;;53229:42;51253:2026;;51149:2130;;;:::o;17626:211::-;17770:58;;;-1:-1:-1;;;;;206:32:1;;17770:58:0;;;188:51:1;255:18;;;;248:34;;;17770:58:0;;;;;;;;;;161:18:1;;;;17770:58:0;;;;;;;;-1:-1:-1;;;;;17770:58:0;-1:-1:-1;;;17770:58:0;;;17743:86;;17763:5;;17743:19;:86::i;43197:1109::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;43308:7:0;43391:13;;43384:4;:20;43353:886;;;43425:31;43459:17;;;:11;:17;;;;;;;;;43425:51;;;;;;;;;-1:-1:-1;;;;;43425:51:0;;;;-1:-1:-1;;;43425:51:0;;;;;;;;;;;-1:-1:-1;;;43425:51:0;;;;;;;;;;;;;;43495:729;;43545:14;;-1:-1:-1;;;;;43545:28:0;;43541:101;;43609:9;43197:1109;-1:-1:-1;;;43197:1109:0:o;43541:101::-;-1:-1:-1;;;43984:6:0;44029:17;;;;:11;:17;;;;;;;;;44017:29;;;;;;;;;-1:-1:-1;;;;;44017:29:0;;;;;-1:-1:-1;;;44017:29:0;;;;;;;;;;;-1:-1:-1;;;44017:29:0;;;;;;;;;;;;;44077:28;44073:109;;44145:9;43197:1109;-1:-1:-1;;;43197:1109:0:o;44073:109::-;43944:261;;;43406:833;43353:886;44267:31;;-1:-1:-1;;;44267:31:0;;;;;;;;;;;8228:191;8321:6;;;-1:-1:-1;;;;;8338:17:0;;;-1:-1:-1;;;;;;8338:17:0;;;;;;;8371:40;;8321:6;;;8338:17;8321:6;;8371:40;;8302:16;;8371:40;8291:128;8228:191;:::o;48231:104::-;48300:27;48310:2;48314:8;48300:27;;;;;;;;;;;;:9;:27::i;56894:667::-;57078:72;;-1:-1:-1;;;57078:72:0;;57057:4;;-1:-1:-1;;;;;57078:36:0;;;;;:72;;5762:10;;57129:4;;57135:7;;57144:5;;57078:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57078:72:0;;;;;;;;-1:-1:-1;;57078:72:0;;;;;;;;;;;;:::i;:::-;;;57074:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57312:6;:13;57329:1;57312:18;57308:235;;57358:40;;-1:-1:-1;;;57358:40:0;;;;;;;;;;;57308:235;57501:6;57495:13;57486:6;57482:2;57478:15;57471:38;57074:480;-1:-1:-1;;;;;;57197:55:0;-1:-1:-1;;;57197:55:0;;-1:-1:-1;57074:480:0;56894:667;;;;;;:::o;3244:723::-;3300:13;3521:5;3530:1;3521:10;3517:53;;-1:-1:-1;;3548:10:0;;;;;;;;;;;;-1:-1:-1;;;3548:10:0;;;;;3244:723::o;3517:53::-;3595:5;3580:12;3636:78;3643:9;;3636:78;;3669:8;;;;:::i;:::-;;-1:-1:-1;3692:10:0;;-1:-1:-1;3700:2:0;3692:10;;:::i;:::-;;;3636:78;;;3724:19;3756:6;3746:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3746:17:0;;3724:39;;3774:154;3781:10;;3774:154;;3808:11;3818:1;3808:11;;:::i;:::-;;-1:-1:-1;3877:10:0;3885:2;3877:5;:10;:::i;:::-;3864:24;;:2;:24;:::i;:::-;3851:39;;3834:6;3841;3834:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;3834:56:0;;;;;;;;-1:-1:-1;3905:11:0;3914:2;3905:11;;:::i;:::-;;;3774:154;;20199:716;20623:23;20649:69;20677:4;20649:69;;;;;;;;;;;;;;;;;20657:5;-1:-1:-1;;;;;20649:27:0;;;:69;;;;;:::i;:::-;20733:17;;20623:95;;-1:-1:-1;20733:21:0;20729:179;;20830:10;20819:30;;;;;;;;;;;;:::i;:::-;20811:85;;;;-1:-1:-1;;;20811:85:0;;17787:2:1;20811:85:0;;;17769:21:1;17826:2;17806:18;;;17799:30;17865:34;17845:18;;;17838:62;-1:-1:-1;;;17916:18:1;;;17909:40;17966:19;;20811:85:0;17585:406:1;48698:163:0;48821:32;48827:2;48831:8;48841:5;48848:4;48821:5;:32::i;12404:229::-;12541:12;12573:52;12595:6;12603:4;12609:1;12612:12;12573:21;:52::i;49120:1775::-;49259:20;49282:13;-1:-1:-1;;;;;49310:16:0;;49306:48;;49335:19;;-1:-1:-1;;;49335:19:0;;;;;;;;;;;49306:48;49369:8;49381:1;49369:13;49365:44;;49391:18;;-1:-1:-1;;;49391:18:0;;;;;;;;;;;49365:44;-1:-1:-1;;;;;49760:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;49819:49:0;;49760:44;;;;;;;;49819:49;;;;-1:-1:-1;;49760:44:0;;;;;;49819:49;;;;;;;;;;;;;;;;49885:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;49935:66:0;;;;-1:-1:-1;;;49985:15:0;49935:66;;;;;;;;;;49885:25;50082:23;;;50126:4;:23;;;;-1:-1:-1;;;;;;50134:13:0;;9954:19;:23;;50134:15;50122:641;;;50170:314;50201:38;;50226:12;;-1:-1:-1;;;;;50201:38:0;;;50218:1;;50201:38;;50218:1;;50201:38;50267:69;50306:1;50310:2;50314:14;;;;;;50330:5;50267:30;:69::i;:::-;50262:174;;50372:40;;-1:-1:-1;;;50372:40:0;;;;;;;;;;;50262:174;50479:3;50463:12;:19;50170:314;;50565:12;50548:13;;:29;50544:43;;50579:8;;;50544:43;50122:641;;;50628:120;50659:40;;50684:14;;;;;-1:-1:-1;;;;;50659:40:0;;;50676:1;;50659:40;;50676:1;;50659:40;50743:3;50727:12;:19;50628:120;;50122:641;-1:-1:-1;50777:13:0;:28;50827:60;47425:369;13524:510;13694:12;13752:5;13727:21;:30;;13719:81;;;;-1:-1:-1;;;13719:81:0;;18198:2:1;13719:81:0;;;18180:21:1;18237:2;18217:18;;;18210:30;18276:34;18256:18;;;18249:62;-1:-1:-1;;;18327:18:1;;;18320:36;18373:19;;13719:81:0;17996:402:1;13719:81:0;-1:-1:-1;;;;;9954:19:0;;;13811:60;;;;-1:-1:-1;;;13811:60:0;;18605:2:1;13811:60:0;;;18587:21:1;18644:2;18624:18;;;18617:30;18683:31;18663:18;;;18656:59;18732:18;;13811:60:0;18403:353:1;13811:60:0;13885:12;13899:23;13926:6;-1:-1:-1;;;;;13926:11:0;13945:5;13952:4;13926:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13884:73;;;;13975:51;13992:7;14001:10;14013:12;13975:16;:51::i;:::-;13968:58;13524:510;-1:-1:-1;;;;;;;13524:510:0:o;16210:712::-;16360:12;16389:7;16385:530;;;-1:-1:-1;16420:10:0;16413:17;;16385:530;16534:17;;:21;16530:374;;16732:10;16726:17;16793:15;16780:10;16776:2;16772:19;16765:44;16530:374;16875:12;16868:20;;-1:-1:-1;;;16868:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;293:131:1;-1:-1:-1;;;;;;367:32:1;;357:43;;347:71;;414:1;411;404:12;429:245;487:6;540:2;528:9;519:7;515:23;511:32;508:52;;;556:1;553;546:12;508:52;595:9;582:23;614:30;638:5;614:30;:::i;871:258::-;943:1;953:113;967:6;964:1;961:13;953:113;;;1043:11;;;1037:18;1024:11;;;1017:39;989:2;982:10;953:113;;;1084:6;1081:1;1078:13;1075:48;;;-1:-1:-1;;1119:1:1;1101:16;;1094:27;871:258::o;1134:::-;1176:3;1214:5;1208:12;1241:6;1236:3;1229:19;1257:63;1313:6;1306:4;1301:3;1297:14;1290:4;1283:5;1279:16;1257:63;:::i;:::-;1374:2;1353:15;-1:-1:-1;;1349:29:1;1340:39;;;;1381:4;1336:50;;1134:258;-1:-1:-1;;1134:258:1:o;1397:220::-;1546:2;1535:9;1528:21;1509:4;1566:45;1607:2;1596:9;1592:18;1584:6;1566:45;:::i;1622:180::-;1681:6;1734:2;1722:9;1713:7;1709:23;1705:32;1702:52;;;1750:1;1747;1740:12;1702:52;-1:-1:-1;1773:23:1;;1622:180;-1:-1:-1;1622:180:1:o;2015:131::-;-1:-1:-1;;;;;2090:31:1;;2080:42;;2070:70;;2136:1;2133;2126:12;2151:315;2219:6;2227;2280:2;2268:9;2259:7;2255:23;2251:32;2248:52;;;2296:1;2293;2286:12;2248:52;2335:9;2322:23;2354:31;2379:5;2354:31;:::i;:::-;2404:5;2456:2;2441:18;;;;2428:32;;-1:-1:-1;;;2151:315:1:o;2653:255::-;2720:6;2773:2;2761:9;2752:7;2748:23;2744:32;2741:52;;;2789:1;2786;2779:12;2741:52;2828:9;2815:23;2847:31;2872:5;2847:31;:::i;2913:456::-;2990:6;2998;3006;3059:2;3047:9;3038:7;3034:23;3030:32;3027:52;;;3075:1;3072;3065:12;3027:52;3114:9;3101:23;3133:31;3158:5;3133:31;:::i;:::-;3183:5;-1:-1:-1;3240:2:1;3225:18;;3212:32;3253:33;3212:32;3253:33;:::i;:::-;2913:456;;3305:7;;-1:-1:-1;;;3359:2:1;3344:18;;;;3331:32;;2913:456::o;3374:401::-;3455:6;3463;3516:2;3504:9;3495:7;3491:23;3487:32;3484:52;;;3532:1;3529;3522:12;3484:52;3571:9;3558:23;3590:31;3615:5;3590:31;:::i;:::-;3640:5;-1:-1:-1;3697:2:1;3682:18;;3669:32;3710:33;3669:32;3710:33;:::i;:::-;3762:7;3752:17;;;3374:401;;;;;:::o;3780:127::-;3841:10;3836:3;3832:20;3829:1;3822:31;3872:4;3869:1;3862:15;3896:4;3893:1;3886:15;3912:632;3977:5;4007:18;4048:2;4040:6;4037:14;4034:40;;;4054:18;;:::i;:::-;4129:2;4123:9;4097:2;4183:15;;-1:-1:-1;;4179:24:1;;;4205:2;4175:33;4171:42;4159:55;;;4229:18;;;4249:22;;;4226:46;4223:72;;;4275:18;;:::i;:::-;4315:10;4311:2;4304:22;4344:6;4335:15;;4374:6;4366;4359:22;4414:3;4405:6;4400:3;4396:16;4393:25;4390:45;;;4431:1;4428;4421:12;4390:45;4481:6;4476:3;4469:4;4461:6;4457:17;4444:44;4536:1;4529:4;4520:6;4512;4508:19;4504:30;4497:41;;;;3912:632;;;;;:::o;4549:451::-;4618:6;4671:2;4659:9;4650:7;4646:23;4642:32;4639:52;;;4687:1;4684;4677:12;4639:52;4727:9;4714:23;4760:18;4752:6;4749:30;4746:50;;;4792:1;4789;4782:12;4746:50;4815:22;;4868:4;4860:13;;4856:27;-1:-1:-1;4846:55:1;;4897:1;4894;4887:12;4846:55;4920:74;4986:7;4981:2;4968:16;4963:2;4959;4955:11;4920:74;:::i;5257:118::-;5343:5;5336:13;5329:21;5322:5;5319:32;5309:60;;5365:1;5362;5355:12;5380:382;5445:6;5453;5506:2;5494:9;5485:7;5481:23;5477:32;5474:52;;;5522:1;5519;5512:12;5474:52;5561:9;5548:23;5580:31;5605:5;5580:31;:::i;:::-;5630:5;-1:-1:-1;5687:2:1;5672:18;;5659:32;5700:30;5659:32;5700:30;:::i;5767:795::-;5862:6;5870;5878;5886;5939:3;5927:9;5918:7;5914:23;5910:33;5907:53;;;5956:1;5953;5946:12;5907:53;5995:9;5982:23;6014:31;6039:5;6014:31;:::i;:::-;6064:5;-1:-1:-1;6121:2:1;6106:18;;6093:32;6134:33;6093:32;6134:33;:::i;:::-;6186:7;-1:-1:-1;6240:2:1;6225:18;;6212:32;;-1:-1:-1;6295:2:1;6280:18;;6267:32;6322:18;6311:30;;6308:50;;;6354:1;6351;6344:12;6308:50;6377:22;;6430:4;6422:13;;6418:27;-1:-1:-1;6408:55:1;;6459:1;6456;6449:12;6408:55;6482:74;6548:7;6543:2;6530:16;6525:2;6521;6517:11;6482:74;:::i;:::-;6472:84;;;5767:795;;;;;;;:::o;7225:380::-;7304:1;7300:12;;;;7347;;;7368:61;;7422:4;7414:6;7410:17;7400:27;;7368:61;7475:2;7467:6;7464:14;7444:18;7441:38;7438:161;;7521:10;7516:3;7512:20;7509:1;7502:31;7556:4;7553:1;7546:15;7584:4;7581:1;7574:15;7438:161;;7225:380;;;:::o;7610:356::-;7812:2;7794:21;;;7831:18;;;7824:30;7890:34;7885:2;7870:18;;7863:62;7957:2;7942:18;;7610:356::o;8729:402::-;8931:2;8913:21;;;8970:2;8950:18;;;8943:30;9009:34;9004:2;8989:18;;8982:62;-1:-1:-1;;;9075:2:1;9060:18;;9053:36;9121:3;9106:19;;8729:402::o;9136:127::-;9197:10;9192:3;9188:20;9185:1;9178:31;9228:4;9225:1;9218:15;9252:4;9249:1;9242:15;9268:128;9308:3;9339:1;9335:6;9332:1;9329:13;9326:39;;;9345:18;;:::i;:::-;-1:-1:-1;9381:9:1;;9268:128::o;9401:407::-;9603:2;9585:21;;;9642:2;9622:18;;;9615:30;9681:34;9676:2;9661:18;;9654:62;-1:-1:-1;;;9747:2:1;9732:18;;9725:41;9798:3;9783:19;;9401:407::o;10100:184::-;10170:6;10223:2;10211:9;10202:7;10198:23;10194:32;10191:52;;;10239:1;10236;10229:12;10191:52;-1:-1:-1;10262:16:1;;10100:184;-1:-1:-1;10100:184:1:o;10289:127::-;10350:10;10345:3;10341:20;10338:1;10331:31;10381:4;10378:1;10371:15;10405:4;10402:1;10395:15;11124:168;11164:7;11230:1;11226;11222:6;11218:14;11215:1;11212:21;11207:1;11200:9;11193:17;11189:45;11186:71;;;11237:18;;:::i;:::-;-1:-1:-1;11277:9:1;;11124:168::o;12813:973::-;12898:12;;12863:3;;12953:1;12973:18;;;;13026;;;;13053:61;;13107:4;13099:6;13095:17;13085:27;;13053:61;13133:2;13181;13173:6;13170:14;13150:18;13147:38;13144:161;;13227:10;13222:3;13218:20;13215:1;13208:31;13262:4;13259:1;13252:15;13290:4;13287:1;13280:15;13144:161;13321:18;13348:104;;;;13466:1;13461:319;;;;13314:466;;13348:104;-1:-1:-1;;13381:24:1;;13369:37;;13426:16;;;;-1:-1:-1;13348:104:1;;13461:319;12760:1;12753:14;;;12797:4;12784:18;;13555:1;13569:165;13583:6;13580:1;13577:13;13569:165;;;13661:14;;13648:11;;;13641:35;13704:16;;;;13598:10;;13569:165;;;13573:3;;13763:6;13758:3;13754:16;13747:23;;13314:466;;;;;;;12813:973;;;;:::o;13791:543::-;14068:3;14096:38;14130:3;14122:6;14096:38;:::i;:::-;14163:6;14157:13;14179:52;14224:6;14220:2;14213:4;14205:6;14201:17;14179:52;:::i;:::-;-1:-1:-1;;;14253:15:1;;14277:22;;;14326:1;14315:13;;13791:543;-1:-1:-1;;;;13791:543:1:o;14339:197::-;14467:3;14492:38;14526:3;14518:6;14492:38;:::i;14948:127::-;15009:10;15004:3;15000:20;14997:1;14990:31;15040:4;15037:1;15030:15;15064:4;15061:1;15054:15;15080:120;15120:1;15146;15136:35;;15151:18;;:::i;:::-;-1:-1:-1;15185:9:1;;15080:120::o;15205:125::-;15245:4;15273:1;15270;15267:8;15264:34;;;15278:18;;:::i;:::-;-1:-1:-1;15315:9:1;;15205:125::o;16330:489::-;-1:-1:-1;;;;;16599:15:1;;;16581:34;;16651:15;;16646:2;16631:18;;16624:43;16698:2;16683:18;;16676:34;;;16746:3;16741:2;16726:18;;16719:31;;;16524:4;;16767:46;;16793:19;;16785:6;16767:46;:::i;:::-;16759:54;16330:489;-1:-1:-1;;;;;;16330:489:1:o;16824:249::-;16893:6;16946:2;16934:9;16925:7;16921:23;16917:32;16914:52;;;16962:1;16959;16952:12;16914:52;16994:9;16988:16;17013:30;17037:5;17013:30;:::i;17078:135::-;17117:3;17138:17;;;17135:43;;17158:18;;:::i;:::-;-1:-1:-1;17205:1:1;17194:13;;17078:135::o;17218:112::-;17250:1;17276;17266:35;;17281:18;;:::i;:::-;-1:-1:-1;17315:9:1;;17218:112::o;17335:245::-;17402:6;17455:2;17443:9;17434:7;17430:23;17426:32;17423:52;;;17471:1;17468;17461:12;17423:52;17503:9;17497:16;17522:28;17544:5;17522:28;:::i;18761:274::-;18890:3;18928:6;18922:13;18944:53;18990:6;18985:3;18978:4;18970:6;18966:17;18944:53;:::i;:::-;19013:16;;;;;18761:274;-1:-1:-1;;18761:274:1:o

Swarm Source

ipfs://659f35d777d510f516780e548280983869c71ce1a9a3bc643324c04663f28b66

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services