Token

RiserBotz (RISERBOTZ)

ERC-721

Overview

Max Total Supply

10,000 RISERBOTZ

Holders

520

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x5d37f5da50051d729fc60e36ee493bbcddd1fb1c

Filtered by Token Holder

0x91e2A8B60B0752371A5abF39a952fd598118c01C

isthatsean.eth

Balance

8 RISERBOTZ

0x91e2A8B60B0752371A5abF39a952fd598118c01C

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

RiserBotz

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 2023-01-17
*/

// SPDX-License-Identifier: MIT


// OpenZeppelin Contracts v4.4.1 

pragma solidity ^0.8.0;

// import "./IERC165-SupportsInterface.sol";

///
/// @dev Interface for the NFT Royalty Standard
///
interface IERC2981 {
    /// ERC165 bytes to add to interface array - set in parent contract
    /// implementing this standard
    ///
    /// bytes4(keccak256("royaltyInfo(uint256,uint256)")) == 0x2a55205a
    /// bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;
    /// _registerInterface(_INTERFACE_ID_ERC2981);

    /// @notice Called with the sale price to determine how much royalty
    //          is owed and to whom.
    /// @param _tokenId - the NFT asset queried for royalty information
    /// @param _salePrice - the sale price of the NFT asset specified by _tokenId
    /// @return receiver - address of who should be sent the royalty payment
    /// @return royaltyAmount - the royalty payment amount for _salePrice
    function royaltyInfo(uint256 _tokenId, uint256 _salePrice) external view returns (
        address receiver,
        uint256 royaltyAmount
    );
}
// File: evm-contracts/src/RiserBotz/IERC173-Ownable.sol



pragma solidity 0.8.13;

interface IOwnable {
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    function owner() external view returns (address);
    function transferOwnership(address newOwner) external;
}

// File: evm-contracts/src/RiserBotz/ErrorNotZeroAddress.sol



pragma solidity 0.8.13;

error NotZeroAddress();    // 0x66385fa3
error CallerNotApproved(); // 0x4014f1a5
error InvalidAddress();    // 0xe6c4247b
// File: evm-contracts/src/RiserBotz/IOperatorFilterRegistry.sol


pragma solidity ^0.8.13;

interface IOperatorFilterRegistry {
    function isOperatorAllowed(address registrant, address operator) external view returns (bool);
    function register(address registrant) external;
    function registerAndSubscribe(address registrant, address subscription) external;
    function registerAndCopyEntries(address registrant, address registrantToCopy) external;
    function unregister(address addr) external;
    function updateOperator(address registrant, address operator, bool filtered) external;
    function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
    function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
    function subscribe(address registrant, address registrantToSubscribe) external;
    function unsubscribe(address registrant, bool copyExistingEntries) external;
    function subscriptionOf(address addr) external returns (address registrant);
    function subscribers(address registrant) external returns (address[] memory);
    function subscriberAt(address registrant, uint256 index) external returns (address);
    function copyEntriesOf(address registrant, address registrantToCopy) external;
    function isOperatorFiltered(address registrant, address operator) external returns (bool);
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
    function filteredOperators(address addr) external returns (address[] memory);
    function filteredCodeHashes(address addr) external returns (bytes32[] memory);
    function filteredOperatorAt(address registrant, uint256 index) external returns (address);
    function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
    function isRegistered(address addr) external returns (bool);
    function codeHashOf(address addr) external returns (bytes32);
}
// File: @openzeppelin/contracts/utils/math/Math.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

// File: @openzeppelin/contracts/utils/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: evm-contracts/src/RiserBotz/ERC173-Ownable.sol



pragma solidity 0.8.13;




error CallerNotOwner();

contract Ownable is IOwnable, Context {
    address public owner;

    function _onlyOwner() private view {
        if (owner != _msgSender()) revert CallerNotOwner();
    }

    modifier onlyOwner() {
        _onlyOwner();
        _;
    }

    constructor() {
        address msgSender = _msgSender();
        owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    // Allow contract ownership and access to contract onlyOwner functions
    // to be locked using EverOwn with control gated by community vote.
    function transferOwnership(address newOwner) external virtual onlyOwner {
        if (newOwner == address(0)) revert NotZeroAddress();

        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }
}
// File: evm-contracts/src/RiserBotz/OperatorFilterer.sol


pragma solidity ^0.8.13;



/**
 * @title  OperatorFilterer
 * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
 *         registrant's entries in the OperatorFilterRegistry.
 * @dev    This smart contract is meant to be inherited by token contracts so they can use the following:
 *         - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
 *         - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
 */
abstract contract OperatorFilterer is Ownable {
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY =
        IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
    bool skipCheck = false; //Just a safety flag to turn off, if something goes wrong

    constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
        // will not revert, but the contract will need to be registered with the registry once it is deployed in
        // order for the modifier to filter addresses.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (subscribe) {
                OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
                } else {
                    OPERATOR_FILTER_REGISTRY.register(address(this));
                }
            }
        }
    }

    modifier onlyAllowedOperator(address from)  {
        // Allow spending tokens from addresses with balance
        // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
        // from an EOA.
        if (!skipCheck) {
            if (from != msg.sender) {
                _checkFilterOperator(msg.sender);
            }
        }
        _;
    }

    modifier onlyAllowedOperatorApproval(address operator)  {
        if (!skipCheck) {
            _checkFilterOperator(operator);
        }
        _;
    }

    function setSkipCheck(bool checkValue) external onlyOwner {
        skipCheck = checkValue;
    }

    function _checkFilterOperator(address operator) internal view virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
                revert OperatorNotAllowed(operator);
            }
        }
    }
}
// File: evm-contracts/src/RiserBotz/DefaultOperatorFilterer.sol


pragma solidity ^0.8.13;


/**
 * @title  DefaultOperatorFilterer
 * @notice Inherits from OperatorFilterer and automatically subscribes to the default OpenSea subscription.
 */
abstract contract DefaultOperatorFilterer is OperatorFilterer {
    address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);

    constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}
// File: @openzeppelin/contracts/utils/Address.sol


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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

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

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// File: evm-contracts/src/RiserBotz/Lockable.sol



pragma solidity ^0.8.13;




error TokensLocked();                 
error LockTimeTooLong();              
error LockTimeTooShort();             
error Unlocked();

abstract contract Lockable is Context {
    using Address for address;
    
    event LockTokens(address indexed account, address indexed altAccount, uint256 length);
    event LockTokensExtend(address indexed account, uint256 length);

    //Lock related fields
    mapping (address => uint48) internal _lockTimestamps;
    mapping(address => address) private _userUnlocks;

    function _tokensLock(address fromAddress) internal view {
        if (isWalletLocked(fromAddress)) revert TokensLocked();
    }

    modifier tokensLock(address fromAddress) {
        _tokensLock(fromAddress);
        _;
    }

    function isWalletLocked(address fromAddress) public view returns(bool) {
        return _lockTimestamps[fromAddress] > block.timestamp;
    }
    
    function lockTokens(address altAccount, uint48 length) external tokensLock(_msgSender()) {
        if (altAccount == address(0)) revert NotZeroAddress();
        if (length / 1 days > 10 * 365 days) revert LockTimeTooLong();

        _lockTimestamps[_msgSender()] = uint48(block.timestamp) + length;
        _userUnlocks[_msgSender()] = altAccount;

        emit LockTokens(_msgSender(), altAccount, length);
    }

    function extendLockTokens(uint48 length) external {
        if (length / 1 days > 10 * 365 days) revert LockTimeTooLong();
        uint48 currentLock = _lockTimestamps[_msgSender()];

        if (currentLock < block.timestamp) revert Unlocked();

        uint48 newLock = uint48(block.timestamp) + length;
        if (currentLock > newLock) revert LockTimeTooShort();
        _lockTimestamps[_msgSender()] = newLock;

        emit LockTokensExtend(_msgSender(), length);
    }

    function unlockTokens(address accountToUnlock) external {
        if (_userUnlocks[accountToUnlock] != _msgSender()) revert CallerNotApproved();
        uint48 currentLock = _lockTimestamps[accountToUnlock];
        if (currentLock < block.timestamp) revert Unlocked();
        _lockTimestamps[accountToUnlock] = 1;
    }
}
// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


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

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/utils/introspection/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 (last updated v4.8.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

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

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

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

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

// File: @openzeppelin/contracts/token/ERC721/extensions/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: evm-contracts/src/RiserBotz/ERC721R.sol



pragma solidity ^0.8.13;












/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension. This does random batch minting.
 */
contract ERC721r is Context, DefaultOperatorFilterer, ERC165, IERC721, IERC721Metadata, IERC2981, Lockable {
    using Address for address;
    using Strings for uint256;

    event RoyaltyFeeUpdated(uint256 newValue);
    event RoyaltyAddressUpdated(address indexed contractAddress);
    
    // Token name
    string private _name;

    // Token symbol
    string private _symbol;
    
    mapping(uint => uint) private _availableTokens;
    uint256 private _numAvailableTokens;
    uint256 immutable _maxSupply;
    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

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

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

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

    //Adding RoyaltyInfo details
    uint256 royaltyFee = 750;
    address royaltyAddress;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_, uint maxSupply_, address rAddress) {
        _name = name_;
        _symbol = symbol_;
        _maxSupply = maxSupply_;
        _numAvailableTokens = maxSupply_;
        royaltyAddress = rAddress;
    }
    
    /**
     * @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);
    }

    function royaltyInfo(
        uint256, /* tokenId */
        uint256 salePrice
    ) public view returns (address receiver, uint256 royaltyAmount) {
        receiver = royaltyAddress;
        royaltyAmount = (royaltyFee * salePrice) / 10000;
    }

    function setRoyaltyAddress(address newAddress) external onlyOwner {
        royaltyAddress = newAddress;
        emit RoyaltyAddressUpdated(newAddress);
    }

    function setRoyaltyFee(uint256 newFee) external onlyOwner {
        royaltyFee = newFee;
        emit RoyaltyFeeUpdated(newFee);
    }
    
    function totalSupply() public view virtual returns (uint256) {
        return _maxSupply - _numAvailableTokens;
    }
    
    function maxSupply() public view virtual returns (uint256) {
        return _maxSupply;
    }

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

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

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

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

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

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

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

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override onlyAllowedOperatorApproval(to) tokensLock(_msgSender()) {
        address owner = ERC721r.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override onlyAllowedOperatorApproval(operator) tokensLock(_msgSender()) {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

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

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

        _transfer(from, to, tokenId);
    }

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

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

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

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

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

    function _mintIdWithoutBalanceUpdate(address to, uint256 tokenId) private {
        _beforeTokenTransfer(address(0), to, tokenId);
        
        _owners[tokenId] = to;
        
        emit Transfer(address(0), to, tokenId);
        
        _afterTokenTransfer(address(0), to, tokenId);
    }

    function _mintRandom(address to, uint _numToMint) internal virtual {
        require(_msgSender() == tx.origin, "Contracts cannot mint");
        require(to != address(0), "ERC721: mint to the zero address");
        require(_numToMint > 0, "ERC721r: need to mint at least one token");
        
        // TODO: Probably don't need this as it will underflow and revert automatically in this case
        require(_numAvailableTokens >= _numToMint, "ERC721r: minting more tokens than available");
        
        uint updatedNumAvailableTokens = _numAvailableTokens;
        for (uint256 i; i < _numToMint; ++i) { // Do this ++ unchecked?
            uint256 tokenId = getRandomAvailableTokenId(to, updatedNumAvailableTokens);
            
            _mintIdWithoutBalanceUpdate(to, tokenId);
            
            --updatedNumAvailableTokens;
        }
        
        _numAvailableTokens = updatedNumAvailableTokens;
        _balances[to] += _numToMint;
    }
        
    function getRandomAvailableTokenId(address to, uint updatedNumAvailableTokens)
        internal
        returns (uint256)
    {
        uint256 randomNum = uint256(
            keccak256(
                abi.encode(
                    to,
                    tx.gasprice,
                    block.number,
                    block.timestamp,
                    block.difficulty,
                    blockhash(block.number - 1),
                    address(this),
                    updatedNumAvailableTokens
                )
            )
        );
        uint256 randomIndex = randomNum % updatedNumAvailableTokens;
        return getAvailableTokenAtIndex(randomIndex, updatedNumAvailableTokens);
    }

    // Implements https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle. Code taken from CryptoPhunksV2
    function getAvailableTokenAtIndex(uint256 indexToUse, uint updatedNumAvailableTokens)
        internal
        returns (uint256)
    {
        uint256 valAtIndex = _availableTokens[indexToUse];
        uint256 result;
        if (valAtIndex == 0) {
            // This means the index itself is still an available token
            result = indexToUse;
        } else {
            // This means the index itself is not an available token, but the val at that index is.
            result = valAtIndex;
        }

        uint256 lastIndex = updatedNumAvailableTokens - 1;
        uint256 lastValInArray = _availableTokens[lastIndex];
        if (indexToUse != lastIndex) {
            // Replace the value at indexToUse, now that it's been used.
            // Replace it with the data from the last index in the array, since we are going to decrease the array size afterwards.
            if (lastValInArray == 0) {
                // This means the index itself is still an available token
                _availableTokens[indexToUse] = lastIndex;
            } else {
                // This means the index itself is not an available token, but the val at that index is.
                _availableTokens[indexToUse] = lastValInArray;
            }
        }
        if (lastValInArray != 0) {
            // Gas refund courtsey of @dievardump
            delete _availableTokens[lastIndex];
        }
        
        return result;
    }
    
    // Not as good as minting a specific tokenId, but will behave the same at the start
    // allowing you to explicitly mint some tokens at launch.
    function _mintAtIndex(address to, uint index) internal virtual {
        require(_msgSender() == tx.origin, "Contracts cannot mint");
        require(to != address(0), "ERC721: mint to the zero address");
        require(_numAvailableTokens >= 1, "ERC721r: minting more tokens than available");
        
        uint tokenId = getAvailableTokenAtIndex(index, _numAvailableTokens);
        --_numAvailableTokens;
        
        _mintIdWithoutBalanceUpdate(to, tokenId);
        
        _balances[to] += 1;
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721r.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

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

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

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

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

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}
// File: evm-contracts/src/RiserBotz/RiserBotz.sol



pragma solidity ^0.8.13;




abstract contract BotzConfigurable is Ownable {

    
    event MintFeeUpdated(uint256 newMintFee);
    event MaxLimitUpdated(uint256 newLimit);
    event MintActiveUpdated(bool active);
    event PreRevealURIUpdated(string uri);

    bool isMintActive = false;
    uint256 maxLimit = 5;
    uint256 public mintFee = 8 * 10**18 / 10**2;
    bool isRevealed = false;
    string preRevealURI = "ipfs://bafkreiarlfjadv23vdgqyt7pbpot7pfwzmrjucuz7c4akngk6b4ixwamay";
    string postRevealBaseURI = "";

    function setMintActive(bool active) external onlyOwner {
        isMintActive = active;
        emit MintActiveUpdated(active);
    }

    function setPreRevalURI(string memory uri) external onlyOwner {
        preRevealURI = uri;
        emit PreRevealURIUpdated(uri);
    }

    function setMaxLimit(uint256 newLimit) external onlyOwner {
        maxLimit = newLimit;
        emit MaxLimitUpdated(newLimit);
    }

    function setMintFee(uint256 newFee, uint256 decimals) external onlyOwner {
        uint256 newMintFee = (newFee * 10**18) / (10 ** decimals);
        mintFee = newMintFee;
        emit MintFeeUpdated(newMintFee);
    }

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

contract RiserBotz is BotzConfigurable, ERC721r {

    error FailedEthSend();
    error MintNotActive();
    error ExceededTheLimit();
    error NotEnoughAmount();
    error AmountMustBeGreaterThanZero();

    constructor(address royaltyAddress) ERC721r ("RiserBotz", "RISERBOTZ", 10_000, royaltyAddress) {

    }

    function mint(address toAddress, uint numOfTokens) public payable {
        if (!isMintActive) _revert(MintNotActive.selector);
        if (numOfTokens > maxLimit) _revert (ExceededTheLimit.selector);
        if (msg.value < numOfTokens * mintFee) _revert (NotEnoughAmount.selector);

        _mintRandom(toAddress, numOfTokens);
    }

    function airDrop(address[] calldata addresses) external onlyOwner {
        for (uint256 i = 0; i < addresses.length; i++) {
            if (addresses[i] == address(0)) _revert (NotZeroAddress.selector);
            _mintRandom(addresses[i], 1);
        }
    }

    //@dev override tokenURI for prereveal
    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        if (!isRevealed) {
            return preRevealURI;
        }
        return super.tokenURI(tokenId);
    }

    //@dev override _baseURI
    function _baseURI() internal view override returns (string memory) {
        return postRevealBaseURI;
    }

    // function sendEthViaCall(address payable to, uint256 amount) private {
    //     (bool sent, ) = to.call{value: amount}("");
    //     if (!sent) revert FailedEthSend();
    // }

    function transferBalance() external onlyOwner {
        uint256 amount = address(this).balance;
        (bool sent, ) = _msgSender().call{value: amount}("");
        if (!sent) revert FailedEthSend();
    }

    function _revert(bytes4 errorSelector) internal pure {
        assembly {
            mstore(0x00, errorSelector)
            revert(0x00, 0x04)
        }
    }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address","name":"royaltyAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AmountMustBeGreaterThanZero","type":"error"},{"inputs":[],"name":"CallerNotApproved","type":"error"},{"inputs":[],"name":"CallerNotOwner","type":"error"},{"inputs":[],"name":"ExceededTheLimit","type":"error"},{"inputs":[],"name":"FailedEthSend","type":"error"},{"inputs":[],"name":"LockTimeTooLong","type":"error"},{"inputs":[],"name":"LockTimeTooShort","type":"error"},{"inputs":[],"name":"MintNotActive","type":"error"},{"inputs":[],"name":"NotEnoughAmount","type":"error"},{"inputs":[],"name":"NotZeroAddress","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"inputs":[],"name":"TokensLocked","type":"error"},{"inputs":[],"name":"Unlocked","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":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"altAccount","type":"address"},{"indexed":false,"internalType":"uint256","name":"length","type":"uint256"}],"name":"LockTokens","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"length","type":"uint256"}],"name":"LockTokensExtend","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newLimit","type":"uint256"}],"name":"MaxLimitUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"active","type":"bool"}],"name":"MintActiveUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newMintFee","type":"uint256"}],"name":"MintFeeUpdated","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":"string","name":"uri","type":"string"}],"name":"PreRevealURIUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"contractAddress","type":"address"}],"name":"RoyaltyAddressUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newValue","type":"uint256"}],"name":"RoyaltyFeeUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"addresses","type":"address[]"}],"name":"airDrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint48","name":"length","type":"uint48"}],"name":"extendLockTokens","outputs":[],"stateMutability":"nonpayable","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":[{"internalType":"address","name":"fromAddress","type":"address"}],"name":"isWalletLocked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"altAccount","type":"address"},{"internalType":"uint48","name":"length","type":"uint48"}],"name":"lockTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"toAddress","type":"address"},{"internalType":"uint256","name":"numOfTokens","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"reveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"royaltyAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newLimit","type":"uint256"}],"name":"setMaxLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"active","type":"bool"}],"name":"setMintActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newFee","type":"uint256"},{"internalType":"uint256","name":"decimals","type":"uint256"}],"name":"setMintFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"uri","type":"string"}],"name":"setPreRevalURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAddress","type":"address"}],"name":"setRoyaltyAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newFee","type":"uint256"}],"name":"setRoyaltyFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"checkValue","type":"bool"}],"name":"setSkipCheck","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"transferBalance","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":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"accountToUnlock","type":"address"}],"name":"unlockTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000d247e827d5ebbd5133ba5159d324bff12472efe9

-----Decoded View---------------
Arg [0] : royaltyAddress (address): 0xd247e827d5ebbD5133Ba5159d324bfF12472efe9

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

Deployed Bytecode Sourcemap

64355:1937:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65035:266;;;;;;;;;;-1:-1:-1;65035:266:0;;;;;:::i;:::-;;:::i;:::-;;46854:305;;;;;;;;;;-1:-1:-1;46854:305:0;;;;;:::i;:::-;;:::i;:::-;;;1185:14:1;;1178:22;1160:41;;1148:2;1133:18;46854:305:0;;;;;;;;47428:161;;;;;;;;;;-1:-1:-1;47428:161:0;;;;;:::i;:::-;;:::i;48612:100::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;50230:221::-;;;;;;;;;;-1:-1:-1;50230:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2681:32:1;;;2663:51;;2651:2;2636:18;50230:221:0;2517:203:1;49695:469:0;;;;;;;;;;-1:-1:-1;49695:469:0;;;;;:::i;:::-;;:::i;34669:143::-;;;;;;;;;;-1:-1:-1;34669:143:0;;;;;:::i;:::-;-1:-1:-1;;;;;34758:28:0;34734:4;34758:28;;;:15;:28;;;;;;34789:15;34758:28;;;;:46;;34669:143;63335:43;;;;;;;;;;;;;;;;;;;3130:25:1;;;3118:2;3103:18;63335:43:0;2984:177:1;47746:119:0;;;;;;;;;;;;;:::i;63986:222::-;;;;;;;;;;-1:-1:-1;63986:222:0;;;;;:::i;:::-;;:::i;51043:382::-;;;;;;;;;;-1:-1:-1;51043:382:0;;;;;:::i;:::-;;:::i;47167:253::-;;;;;;;;;;-1:-1:-1;47167:253:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;3944:32:1;;;3926:51;;4008:2;3993:18;;3986:34;;;;3899:18;47167:253:0;3752:274:1;47597:137:0;;;;;;;;;;-1:-1:-1;47597:137:0;;;;;:::i;:::-;;:::i;64686:341::-;;;;;;:::i;:::-;;:::i;21613:143::-;;;;;;;;;;;;21713:42;21613:143;;51496:228;;;;;;;;;;-1:-1:-1;51496:228:0;;;;;:::i;:::-;;:::i;64216:132::-;;;;;;;;;;-1:-1:-1;64216:132:0;;;;;:::i;:::-;;:::i;35254:487::-;;;;;;;;;;-1:-1:-1;35254:487:0;;;;;:::i;:::-;;:::i;48306:239::-;;;;;;;;;;-1:-1:-1;48306:239:0;;;;;:::i;:::-;;:::i;34824:422::-;;;;;;;;;;-1:-1:-1;34824:422:0;;;;;:::i;:::-;;:::i;65904:210::-;;;;;;;;;;;;;:::i;48036:208::-;;;;;;;;;;-1:-1:-1;48036:208:0;;;;;:::i;:::-;;:::i;63694:139::-;;;;;;;;;;-1:-1:-1;63694:139:0;;;;;:::i;:::-;;:::i;20138:20::-;;;;;;;;;;-1:-1:-1;20138:20:0;;;;-1:-1:-1;;;;;20138:20:0;;;23357:99;;;;;;;;;;-1:-1:-1;23357:99:0;;;;;:::i;:::-;;:::i;48781:104::-;;;;;;;;;;;;;:::i;50523:218::-;;;;;;;;;;-1:-1:-1;50523:218:0;;;;;:::i;:::-;;:::i;51795:371::-;;;;;;;;;;-1:-1:-1;51795:371:0;;;;;:::i;:::-;;:::i;63841:137::-;;;;;;;;;;-1:-1:-1;63841:137:0;;;;;:::i;:::-;;:::i;65353:202::-;;;;;;;;;;-1:-1:-1;65353:202:0;;;;;:::i;:::-;;:::i;35749:326::-;;;;;;;;;;-1:-1:-1;35749:326:0;;;;;:::i;:::-;;:::i;47877:95::-;;;;;;;;;;-1:-1:-1;47954:10:0;47877:95;;50812:164;;;;;;;;;;-1:-1:-1;50812:164:0;;;;;:::i;:::-;;:::i;63550:136::-;;;;;;;;;;-1:-1:-1;63550:136:0;;;;;:::i;:::-;;:::i;20660:224::-;;;;;;;;;;-1:-1:-1;20660:224:0;;;;;:::i;:::-;;:::i;65035:266::-;20311:12;:10;:12::i;:::-;65117:9:::1;65112:182;65132:20:::0;;::::1;65112:182;;;65202:1;65178:9:::0;;65188:1;65178:12;;::::1;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;65178:26:0::1;::::0;65174:65:::1;;65206:33;-1:-1:-1::0;;;65206:7:0::1;:33::i;:::-;65254:28;65266:9;;65276:1;65266:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;65280:1;65254:11;:28::i;:::-;65154:3:::0;::::1;::::0;::::1;:::i;:::-;;;;65112:182;;;;65035:266:::0;;:::o;46854:305::-;46956:4;-1:-1:-1;;;;;;46993:40:0;;-1:-1:-1;;;46993:40:0;;:105;;-1:-1:-1;;;;;;;47050:48:0;;-1:-1:-1;;;47050:48:0;46993:105;:158;;;-1:-1:-1;;;;;;;;;;39025:40:0;;;47115:36;46973:178;46854:305;-1:-1:-1;;46854:305:0:o;47428:161::-;20311:12;:10;:12::i;:::-;47505:14:::1;:27:::0;;-1:-1:-1;;;;;;47505:27:0::1;-1:-1:-1::0;;;;;47505:27:0;::::1;::::0;;::::1;::::0;;;47548:33:::1;::::0;::::1;::::0;-1:-1:-1;;47548:33:0::1;47428:161:::0;:::o;48612:100::-;48666:13;48699:5;48692:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48612:100;:::o;50230:221::-;50306:7;53765:16;;;:7;:16;;;;;;-1:-1:-1;;;;;53765:16:0;50326:73;;;;-1:-1:-1;;;50326:73:0;;8736:2:1;50326:73:0;;;8718:21:1;8775:2;8755:18;;;8748:30;8814:34;8794:18;;;8787:62;-1:-1:-1;;;8865:18:1;;;8858:42;8917:19;;50326:73:0;;;;;;;;;-1:-1:-1;50419:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;50419:24:0;;50230:221::o;49695:469::-;23262:9;;49793:2;;23262:9;;23257:73;;23288:30;23309:8;23288:20;:30::i;:::-;19836:10;34617:24:::1;34629:11;34617;:24::i;:::-;49833:13:::2;49849:24;49865:7;49849:15;:24::i;:::-;49833:40;;49898:5;-1:-1:-1::0;;;;;49892:11:0::2;:2;-1:-1:-1::0;;;;;49892:11:0::2;::::0;49884:57:::2;;;::::0;-1:-1:-1;;;49884:57:0;;9149:2:1;49884:57:0::2;::::0;::::2;9131:21:1::0;9188:2;9168:18;;;9161:30;9227:34;9207:18;;;9200:62;-1:-1:-1;;;9278:18:1;;;9271:31;9319:19;;49884:57:0::2;8947:397:1::0;49884:57:0::2;19836:10:::0;-1:-1:-1;;;;;49976:21:0;::::2;;::::0;:62:::2;;-1:-1:-1::0;50001:37:0::2;50018:5:::0;19836:10;50812:164;:::i;50001:37::-:2;49954:168;;;::::0;-1:-1:-1;;;49954:168:0;;9551:2:1;49954:168:0::2;::::0;::::2;9533:21:1::0;9590:2;9570:18;;;9563:30;9629:34;9609:18;;;9602:62;9700:26;9680:18;;;9673:54;9744:19;;49954:168:0::2;9349:420:1::0;49954:168:0::2;50135:21;50144:2;50148:7;50135:8;:21::i;:::-;49822:342;23340:1:::1;49695:469:::0;;;:::o;47746:119::-;47798:7;47838:19;;47825:10;:32;;;;:::i;:::-;47818:39;;47746:119;:::o;63986:222::-;20311:12;:10;:12::i;:::-;64070:18:::1;64112:14;64118:8:::0;64112:2:::1;:14;:::i;:::-;64092:15;:6:::0;64101::::1;64092:15;:::i;:::-;64091:36;;;;:::i;:::-;64138:7;:20:::0;;;64174:26:::1;::::0;3130:25:1;;;64070:57:0;;-1:-1:-1;64174:26:0::1;::::0;3118:2:1;3103:18;64174:26:0::1;;;;;;;64059:149;63986:222:::0;;:::o;51043:382::-;23035:9;;51186:4;;23035:9;;23030:133;;-1:-1:-1;;;;;23065:18:0;;23073:10;23065:18;23061:91;;23104:32;23125:10;23104:20;:32::i;:::-;51203:4:::1;34617:24;34629:11;34617;:24::i;:::-;51281:41:::2;19836:10:::0;51314:7:::2;51281:18;:41::i;:::-;51273:103;;;;-1:-1:-1::0;;;51273:103:0::2;;;;;;;:::i;:::-;51389:28;51399:4;51405:2;51409:7;51389:9;:28::i;47167:253::-:0;47339:14;;47381:10;;-1:-1:-1;;;;;47339:14:0;;;;47276:16;;47407:5;;47381:22;;47394:9;;47381:22;:::i;:::-;47380:32;;;;:::i;:::-;47364:48;;47167:253;;;;;:::o;47597:137::-;20311:12;:10;:12::i;:::-;47666:10:::1;:19:::0;;;47701:25:::1;::::0;3130::1;;;47701::0::1;::::0;3118:2:1;3103:18;47701:25:0::1;;;;;;;;47597:137:::0;:::o;64686:341::-;64768:12;;-1:-1:-1;;;64768:12:0;;;;64763:50;;64782:31;-1:-1:-1;;;64782:7:0;:31::i;:::-;64842:8;;64828:11;:22;64824:63;;;64852:35;-1:-1:-1;;;64852:7:0;:35::i;:::-;64928:7;;64914:21;;:11;:21;:::i;:::-;64902:9;:33;64898:73;;;64937:34;-1:-1:-1;;;64937:7:0;:34::i;:::-;64984:35;64996:9;65007:11;64984;:35::i;:::-;64686:341;;:::o;51496:228::-;23035:9;;51643:4;;23035:9;;23030:133;;-1:-1:-1;;;;;23065:18:0;;23073:10;23065:18;23061:91;;23104:32;23125:10;23104:20;:32::i;:::-;51660:4:::1;34617:24;34629:11;34617;:24::i;:::-;51677:39:::2;51694:4;51700:2;51704:7;51677:39;;;;;;;;;;;::::0;:16:::2;:39::i;64216:132::-:0;20311:12;:10;:12::i;:::-;64285:27;;::::1;::::0;:17:::1;::::0;:27:::1;::::0;::::1;::::0;::::1;:::i;:::-;-1:-1:-1::0;;64323:10:0::1;:17:::0;;-1:-1:-1;;64323:17:0::1;64336:4;64323:17;::::0;;64216:132::o;35254:487::-;35337:13;35319:15;35328:6;35319;:15;:::i;:::-;:31;;;35315:61;;;35359:17;;-1:-1:-1;;;35359:17:0;;;;;;;;;;;35315:61;19836:10;35387:18;35408:29;;;:15;:29;;;;;;;;35468:15;35454:29;;35450:52;;;35492:10;;-1:-1:-1;;;35492:10:0;;;;;;;;;;;35450:52;35515:14;35532:32;35558:6;35539:15;35532:32;:::i;:::-;35515:49;;35593:7;35579:21;;:11;:21;;;35575:52;;;35609:18;;-1:-1:-1;;;35609:18:0;;;;;;;;;;;35575:52;19836:10;35638:29;;;;:15;:29;;;;;;;;;:39;;-1:-1:-1;;35638:39:0;;;;;;;;;;;;35695:38;;12726:27:1;;;12708:46;;35695:38:0;;;;;;;;;;;;35304:437;;35254:487;:::o;48306:239::-;48378:7;48414:16;;;:7;:16;;;;;;-1:-1:-1;;;;;48414:16:0;;48441:73;;;;-1:-1:-1;;;48441:73:0;;12967:2:1;48441:73:0;;;12949:21:1;13006:2;12986:18;;;12979:30;13045:34;13025:18;;;13018:62;-1:-1:-1;;;13096:18:1;;;13089:39;13145:19;;48441:73:0;12765:405:1;34824:422:0;19836:10;34617:24;34629:11;34617;:24::i;:::-;-1:-1:-1;;;;;34928:24:0;::::1;34924:53;;34961:16;;-1:-1:-1::0;;;34961:16:0::1;;;;;;;;;;;34924:53;35010:13;34992:15;35001:6;34992::::0;:15:::1;:::i;:::-;:31;;;34988:61;;;35032:17;;-1:-1:-1::0;;;35032:17:0::1;;;;;;;;;;;34988:61;35094:32;35120:6:::0;35101:15:::1;35094:32;:::i;:::-;19836:10:::0;35062:29:::1;::::0;;;:15:::1;:29;::::0;;;;;;;:64;;-1:-1:-1;;35062:64:0::1;;::::0;;::::1;;::::0;;35137:12:::1;:26:::0;;;;;;:39;;-1:-1:-1;;;;;;35137:39:0::1;-1:-1:-1::0;;;;;35137:39:0;::::1;::::0;;::::1;::::0;;;35194:44;;12726:27:1;;;12708:46;;35137:39:0;;35194:44:::1;::::0;12681:18:1;35194:44:0::1;;;;;;;;34824:422:::0;;;:::o;65904:210::-;20311:12;:10;:12::i;:::-;66026:36:::1;::::0;65978:21:::1;::::0;65961:14:::1;::::0;19836:10;;65978:21;;65961:14;66026:36;65961:14;66026:36;65978:21;19836:10;66026:36:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66010:52;;;66078:4;66073:33;;66091:15;;-1:-1:-1::0;;;66091:15:0::1;;;;;;;;;;;48036:208:::0;48108:7;-1:-1:-1;;;;;48136:19:0;;48128:74;;;;-1:-1:-1;;;48128:74:0;;13587:2:1;48128:74:0;;;13569:21:1;13626:2;13606:18;;;13599:30;13665:34;13645:18;;;13638:62;-1:-1:-1;;;13716:18:1;;;13709:40;13766:19;;48128:74:0;13385:406:1;48128:74:0;-1:-1:-1;;;;;;48220:16:0;;;;;:9;:16;;;;;;;48036:208::o;63694:139::-;20311:12;:10;:12::i;:::-;63767:18;;::::1;::::0;:12:::1;::::0;:18:::1;::::0;::::1;::::0;::::1;:::i;:::-;;63801:24;63821:3;63801:24;;;;;;:::i;23357:99::-:0;20311:12;:10;:12::i;:::-;23426:9:::1;:22:::0;;-1:-1:-1;;23426:22:0::1;::::0;::::1;;::::0;;;::::1;::::0;;23357:99::o;48781:104::-;48837:13;48870:7;48863:14;;;;;:::i;50523:218::-;23262:9;;50635:8;;23262:9;;23257:73;;23288:30;23309:8;23288:20;:30::i;:::-;19836:10;34617:24:::1;34629:11;34617;:24::i;:::-;50681:52:::2;19836:10:::0;50714:8:::2;50724;50681:18;:52::i;:::-;23340:1:::1;50523:218:::0;;;:::o;51795:371::-;23035:9;;51971:4;;23035:9;;23030:133;;-1:-1:-1;;;;;23065:18:0;;23073:10;23065:18;23061:91;;23104:32;23125:10;23104:20;:32::i;:::-;51988:4:::1;34617:24;34629:11;34617;:24::i;:::-;52013:41:::2;19836:10:::0;52046:7:::2;52013:18;:41::i;:::-;52005:103;;;;-1:-1:-1::0;;;52005:103:0::2;;;;;;;:::i;:::-;52119:39;52133:4;52139:2;52143:7;52152:5;52119:13;:39::i;:::-;23173:1:::1;51795:371:::0;;;;;:::o;63841:137::-;20311:12;:10;:12::i;:::-;63910:8:::1;:19:::0;;;63945:25:::1;::::0;3130::1;;;63945::0::1;::::0;3118:2:1;3103:18;63945:25:0::1;2984:177:1::0;65353:202:0;65449:10;;65418:13;;65449:10;;65444:63;;65483:12;65476:19;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65353:202;;;:::o;65444:63::-;65524:23;65539:7;65524:14;:23::i;35749:326::-;-1:-1:-1;;;;;35820:29:0;;;;;;;:12;:29;;;;;;;19836:10;35820:45;35816:77;;35874:19;;-1:-1:-1;;;35874:19:0;;;;;;;;;;;35816:77;-1:-1:-1;;;;;35925:32:0;;35904:18;35925:32;;;:15;:32;;;;;;;;35986:15;35972:29;;35968:52;;;36010:10;;-1:-1:-1;;;36010:10:0;;;;;;;;;;;35968:52;-1:-1:-1;;;;;;36031:32:0;;;;;:15;:32;;;;;:36;;-1:-1:-1;;36031:36:0;36066:1;36031:36;;;35749:326::o;50812:164::-;-1:-1:-1;;;;;50933:25:0;;;50909:4;50933:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;50812:164::o;63550:136::-;20311:12;:10;:12::i;:::-;63616::::1;:21:::0;;;::::1;;-1:-1:-1::0;;;63616:21:0::1;-1:-1:-1::0;;;;63616:21:0;;::::1;;::::0;;63653:25:::1;::::0;::::1;::::0;::::1;::::0;63631:6;1185:14:1;1178:22;1160:41;;1148:2;1133:18;;1020:187;20660:224:0;20311:12;:10;:12::i;:::-;-1:-1:-1;;;;;20747:22:0;::::1;20743:51;;20778:16;;-1:-1:-1::0;;;20778:16:0::1;;;;;;;;;;;20743:51;20833:5;::::0;;20812:37:::1;::::0;-1:-1:-1;;;;;20812:37:0;;::::1;::::0;20833:5;::::1;::::0;20812:37:::1;::::0;::::1;20860:5;:16:::0;;-1:-1:-1;;;;;;20860:16:0::1;-1:-1:-1::0;;;;;20860:16:0;;;::::1;::::0;;;::::1;::::0;;20660:224::o;20167:104::-;20217:5;;-1:-1:-1;;;;;20217:5:0;19836:10;20217:21;20213:50;;20247:16;;-1:-1:-1;;;20247:16:0;;;;;;;;;;;20213:50;20167:104::o;66122:165::-;66223:13;66217:4;66210:27;66264:4;66258;66251:18;54639:984;19836:10;54741:9;54725:25;54717:59;;;;-1:-1:-1;;;54717:59:0;;13998:2:1;54717:59:0;;;13980:21:1;14037:2;14017:18;;;14010:30;-1:-1:-1;;;14056:18:1;;;14049:51;14117:18;;54717:59:0;13796:345:1;54717:59:0;-1:-1:-1;;;;;54795:16:0;;54787:61;;;;-1:-1:-1;;;54787:61:0;;14348:2:1;54787:61:0;;;14330:21:1;;;14367:18;;;14360:30;14426:34;14406:18;;;14399:62;14478:18;;54787:61:0;14146:356:1;54787:61:0;54880:1;54867:10;:14;54859:67;;;;-1:-1:-1;;;54859:67:0;;14709:2:1;54859:67:0;;;14691:21:1;14748:2;14728:18;;;14721:30;14787:34;14767:18;;;14760:62;-1:-1:-1;;;14838:18:1;;;14831:38;14886:19;;54859:67:0;14507:404:1;54859:67:0;55080:10;55057:19;;:33;;55049:89;;;;-1:-1:-1;;;55049:89:0;;15118:2:1;55049:89:0;;;15100:21:1;15157:2;15137:18;;;15130:30;15196:34;15176:18;;;15169:62;-1:-1:-1;;;15247:18:1;;;15240:41;15298:19;;55049:89:0;14916:407:1;55049:89:0;55192:19;;55159:30;55222:288;55242:10;55238:1;:14;55222:288;;;55299:15;55317:56;55343:2;55347:25;55317;:56::i;:::-;55299:74;;55402:40;55430:2;55434:7;55402:27;:40::i;:::-;55471:27;;;:::i;:::-;;;55259:251;55254:3;;;;:::i;:::-;;;55222:288;;;-1:-1:-1;55530:19:0;:47;;;-1:-1:-1;;;;;55588:13:0;;;;;;:9;:13;;;;;:27;;55605:10;;55588:13;:27;;55605:10;;55588:27;:::i;:::-;;;;-1:-1:-1;;;;;54639:984:0:o;23464:419::-;21713:42;23655:45;:49;23651:225;;23726:67;;-1:-1:-1;;;23726:67:0;;23777:4;23726:67;;;15814:34:1;-1:-1:-1;;;;;15884:15:1;;15864:18;;;15857:43;21713:42:0;;23726;;15749:18:1;;23726:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;23721:144;;23821:28;;-1:-1:-1;;;23821:28:0;;-1:-1:-1;;;;;2681:32:1;;23821:28:0;;;2663:51:1;2636:18;;23821:28:0;2517:203:1;23721:144:0;23464:419;:::o;34428:129::-;-1:-1:-1;;;;;34758:28:0;;34734:4;34758:28;;;:15;:28;;;;;;34789:15;34758:28;;;;:46;34495:54;;;34535:14;;-1:-1:-1;;;34535:14:0;;;;;;;;;;;59732:175;59807:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;59807:29:0;-1:-1:-1;;;;;59807:29:0;;;;;;;;:24;;59861;59807;59861:15;:24::i;:::-;-1:-1:-1;;;;;59852:47:0;;;;;;;;;;;59732:175;;:::o;53970:349::-;54063:4;53765:16;;;:7;:16;;;;;;-1:-1:-1;;;;;53765:16:0;54080:73;;;;-1:-1:-1;;;54080:73:0;;16363:2:1;54080:73:0;;;16345:21:1;16402:2;16382:18;;;16375:30;16441:34;16421:18;;;16414:62;-1:-1:-1;;;16492:18:1;;;16485:42;16544:19;;54080:73:0;16161:408:1;54080:73:0;54164:13;54180:24;54196:7;54180:15;:24::i;:::-;54164:40;;54234:5;-1:-1:-1;;;;;54223:16:0;:7;-1:-1:-1;;;;;54223:16:0;;:51;;;;54267:7;-1:-1:-1;;;;;54243:31:0;:20;54255:7;54243:11;:20::i;:::-;-1:-1:-1;;;;;54243:31:0;;54223:51;:87;;;;54278:32;54295:5;54302:7;54278:16;:32::i;:::-;54215:96;53970:349;-1:-1:-1;;;;53970:349:0:o;58988:626::-;59148:4;-1:-1:-1;;;;;59120:32:0;:24;59136:7;59120:15;:24::i;:::-;-1:-1:-1;;;;;59120:32:0;;59112:82;;;;-1:-1:-1;;;59112:82:0;;16776:2:1;59112:82:0;;;16758:21:1;16815:2;16795:18;;;16788:30;16854:34;16834:18;;;16827:62;-1:-1:-1;;;16905:18:1;;;16898:35;16950:19;;59112:82:0;16574:401:1;59112:82:0;-1:-1:-1;;;;;59213:16:0;;59205:65;;;;-1:-1:-1;;;59205:65:0;;17182:2:1;59205:65:0;;;17164:21:1;17221:2;17201:18;;;17194:30;17260:34;17240:18;;;17233:62;-1:-1:-1;;;17311:18:1;;;17304:34;17355:19;;59205:65:0;16980:400:1;59205:65:0;59387:29;59404:1;59408:7;59387:8;:29::i;:::-;-1:-1:-1;;;;;59429:15:0;;;;;;:9;:15;;;;;:20;;59448:1;;59429:15;:20;;59448:1;;59429:20;:::i;:::-;;;;-1:-1:-1;;;;;;;59460:13:0;;;;;;:9;:13;;;;;:18;;59477:1;;59460:13;:18;;59477:1;;59460:18;:::i;:::-;;;;-1:-1:-1;;59489:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;59489:21:0;-1:-1:-1;;;;;59489:21:0;;;;;;;;;59528:27;;59489:16;;59528:27;;;;;;;65112:182:::1;65035:266:::0;;:::o;60049:315::-;60204:8;-1:-1:-1;;;;;60195:17:0;:5;-1:-1:-1;;;;;60195:17:0;;60187:55;;;;-1:-1:-1;;;60187:55:0;;17587:2:1;60187:55:0;;;17569:21:1;17626:2;17606:18;;;17599:30;17665:27;17645:18;;;17638:55;17710:18;;60187:55:0;17385:349:1;60187:55:0;-1:-1:-1;;;;;60253:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;60253:46:0;;;;;;;;;;60315:41;;1160::1;;;60315::0;;1133:18:1;60315:41:0;1020:187:1;53048:315:0;53205:28;53215:4;53221:2;53225:7;53205:9;:28::i;:::-;53252:48;53275:4;53281:2;53285:7;53294:5;53252:22;:48::i;:::-;53244:111;;;;-1:-1:-1;;;53244:111:0;;;;;;;:::i;48956:334::-;53741:4;53765:16;;;:7;:16;;;;;;49029:13;;-1:-1:-1;;;;;53765:16:0;49055:76;;;;-1:-1:-1;;;49055:76:0;;18360:2:1;49055:76:0;;;18342:21:1;18399:2;18379:18;;;18372:30;18438:34;18418:18;;;18411:62;-1:-1:-1;;;18489:18:1;;;18482:45;18544:19;;49055:76:0;18158:411:1;49055:76:0;49144:21;49168:10;:8;:10::i;:::-;49144:34;;49220:1;49202:7;49196:21;:25;:86;;;;;;;;;;;;;;;;;49248:7;49257:18;:7;:16;:18::i;:::-;49231:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;49196:86;49189:93;48956:334;-1:-1:-1;;;48956:334:0:o;55639:730::-;55754:7;;55882:2;55907:11;55941:12;55976:15;56014:16;56063;56078:1;55941:12;56063:16;:::i;:::-;55849:334;;;-1:-1:-1;;;;;19448:15:1;;;55849:334:0;;;19430:34:1;19480:18;;19473:34;;;;19523:18;;;19516:34;;;;19566:18;;;19559:34;19609:19;;;19602:35;56053:27:0;19653:19:1;;;19646:35;56111:4:0;19697:19:1;;;19690:44;19750:19;;;19743:35;;;19364:19;;55849:334:0;;;-1:-1:-1;;55849:334:0;;;;;;;;;55821:377;;55849:334;55821:377;;;;;-1:-1:-1;55799:410:0;56242:37;56254:25;55821:377;56242:37;:::i;:::-;56220:59;;56297:64;56322:11;56335:25;56297:24;:64::i;:::-;56290:71;55639:730;-1:-1:-1;;;;;55639:730:0:o;54327:304::-;54478:16;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;54478:21:0;-1:-1:-1;;;;;54478:21:0;;;;;;;;54525:33;;54478:16;;;54525:33;;54478:16;;54525:33;64686:341;;:::o;60929:799::-;61084:4;-1:-1:-1;;;;;61105:13:0;;25906:19;:23;61101:620;;61141:72;;-1:-1:-1;;;61141:72:0;;-1:-1:-1;;;;;61141:36:0;;;;;:72;;19836:10;;61192:4;;61198:7;;61207:5;;61141:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;61141:72:0;;;;;;;;-1:-1:-1;;61141:72:0;;;;;;;;;;;;:::i;:::-;;;61137:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61383:6;:13;61400:1;61383:18;61379:272;;61426:60;;-1:-1:-1;;;61426:60:0;;;;;;;:::i;61379:272::-;61601:6;61595:13;61586:6;61582:2;61578:15;61571:38;61137:529;-1:-1:-1;;;;;;61264:51:0;-1:-1:-1;;;61264:51:0;;-1:-1:-1;61257:58:0;;61101:620;-1:-1:-1;61705:4:0;60929:799;;;;;;:::o;65593:110::-;65645:13;65678:17;65671:24;;;;;:::i;17183:716::-;17239:13;17290:14;17307:17;17318:5;17307:10;:17::i;:::-;17327:1;17307:21;17290:38;;17343:20;17377:6;17366:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17366:18:0;-1:-1:-1;17343:41:0;-1:-1:-1;17508:28:0;;;17524:2;17508:28;17565:288;-1:-1:-1;;17597:5:0;-1:-1:-1;;;17734:2:0;17723:14;;17718:30;17597:5;17705:44;17795:2;17786:11;;;-1:-1:-1;17816:21:0;17565:288;17816:21;-1:-1:-1;17874:6:0;17183:716;-1:-1:-1;;;17183:716:0:o;56487:1476::-;56609:7;56655:28;;;:16;:28;;;;;;56609:7;56723:15;;;56719:292;;-1:-1:-1;56836:10:0;56719:292;;;-1:-1:-1;56989:10:0;56719:292;57023:17;57043:29;57071:1;57043:25;:29;:::i;:::-;57083:22;57108:27;;;:16;:27;;;;;;57023:49;;-1:-1:-1;57150:23:0;;;57146:629;;57401:14;57419:1;57401:19;57397:367;;57517:28;;;;:16;:28;;;;;:40;;;57397:367;;;57703:28;;;;:16;:28;;;;;:45;;;57397:367;57789:19;;57785:137;;57883:27;;;;:16;:27;;;;;57876:34;57785:137;-1:-1:-1;57949:6:0;;56487:1476;-1:-1:-1;;;;;56487:1476:0:o;14049:922::-;14102:7;;-1:-1:-1;;;14180:15:0;;14176:102;;-1:-1:-1;;;14216:15:0;;;-1:-1:-1;14260:2:0;14250:12;14176:102;14305:6;14296:5;:15;14292:102;;14341:6;14332:15;;;-1:-1:-1;14376:2:0;14366:12;14292:102;14421:6;14412:5;:15;14408:102;;14457:6;14448:15;;;-1:-1:-1;14492:2:0;14482:12;14408:102;14537:5;14528;:14;14524:99;;14572:5;14563:14;;;-1:-1:-1;14606:1:0;14596:11;14524:99;14650:5;14641;:14;14637:99;;14685:5;14676:14;;;-1:-1:-1;14719:1:0;14709:11;14637:99;14763:5;14754;:14;14750:99;;14798:5;14789:14;;;-1:-1:-1;14832:1:0;14822:11;14750:99;14876:5;14867;:14;14863:66;;14912:1;14902:11;14957:6;14049:922;-1:-1:-1;;14049:922:0:o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:615:1;100:6;108;161:2;149:9;140:7;136:23;132:32;129:52;;;177:1;174;167:12;129:52;217:9;204:23;246:18;287:2;279:6;276:14;273:34;;;303:1;300;293:12;273:34;341:6;330:9;326:22;316:32;;386:7;379:4;375:2;371:13;367:27;357:55;;408:1;405;398:12;357:55;448:2;435:16;474:2;466:6;463:14;460:34;;;490:1;487;480:12;460:34;543:7;538:2;528:6;525:1;521:14;517:2;513:23;509:32;506:45;503:65;;;564:1;561;554:12;503:65;595:2;587:11;;;;;617:6;;-1:-1:-1;14:615:1;;-1:-1:-1;;;;14:615:1:o;634:131::-;-1:-1:-1;;;;;;708:32:1;;698:43;;688:71;;755:1;752;745:12;770:245;828:6;881:2;869:9;860:7;856:23;852:32;849:52;;;897:1;894;887:12;849:52;936:9;923:23;955:30;979:5;955:30;:::i;1212:173::-;1280:20;;-1:-1:-1;;;;;1329:31:1;;1319:42;;1309:70;;1375:1;1372;1365:12;1309:70;1212:173;;;:::o;1390:186::-;1449:6;1502:2;1490:9;1481:7;1477:23;1473:32;1470:52;;;1518:1;1515;1508:12;1470:52;1541:29;1560:9;1541:29;:::i;1581:258::-;1653:1;1663:113;1677:6;1674:1;1671:13;1663:113;;;1753:11;;;1747:18;1734:11;;;1727:39;1699:2;1692:10;1663:113;;;1794:6;1791:1;1788:13;1785:48;;;-1:-1:-1;;1829:1:1;1811:16;;1804:27;1581:258::o;1844:::-;1886:3;1924:5;1918:12;1951:6;1946:3;1939:19;1967:63;2023:6;2016:4;2011:3;2007:14;2000:4;1993:5;1989:16;1967:63;:::i;:::-;2084:2;2063:15;-1:-1:-1;;2059:29:1;2050:39;;;;2091:4;2046:50;;1844:258;-1:-1:-1;;1844:258:1:o;2107:220::-;2256:2;2245:9;2238:21;2219:4;2276:45;2317:2;2306:9;2302:18;2294:6;2276:45;:::i;2332:180::-;2391:6;2444:2;2432:9;2423:7;2419:23;2415:32;2412:52;;;2460:1;2457;2450:12;2412:52;-1:-1:-1;2483:23:1;;2332:180;-1:-1:-1;2332:180:1:o;2725:254::-;2793:6;2801;2854:2;2842:9;2833:7;2829:23;2825:32;2822:52;;;2870:1;2867;2860:12;2822:52;2893:29;2912:9;2893:29;:::i;:::-;2883:39;2969:2;2954:18;;;;2941:32;;-1:-1:-1;;;2725:254:1:o;3166:248::-;3234:6;3242;3295:2;3283:9;3274:7;3270:23;3266:32;3263:52;;;3311:1;3308;3301:12;3263:52;-1:-1:-1;;3334:23:1;;;3404:2;3389:18;;;3376:32;;-1:-1:-1;3166:248:1:o;3419:328::-;3496:6;3504;3512;3565:2;3553:9;3544:7;3540:23;3536:32;3533:52;;;3581:1;3578;3571:12;3533:52;3604:29;3623:9;3604:29;:::i;:::-;3594:39;;3652:38;3686:2;3675:9;3671:18;3652:38;:::i;:::-;3642:48;;3737:2;3726:9;3722:18;3709:32;3699:42;;3419:328;;;;;:::o;4270:127::-;4331:10;4326:3;4322:20;4319:1;4312:31;4362:4;4359:1;4352:15;4386:4;4383:1;4376:15;4402:632;4467:5;4497:18;4538:2;4530:6;4527:14;4524:40;;;4544:18;;:::i;:::-;4619:2;4613:9;4587:2;4673:15;;-1:-1:-1;;4669:24:1;;;4695:2;4665:33;4661:42;4649:55;;;4719:18;;;4739:22;;;4716:46;4713:72;;;4765:18;;:::i;:::-;4805:10;4801:2;4794:22;4834:6;4825:15;;4864:6;4856;4849:22;4904:3;4895:6;4890:3;4886:16;4883:25;4880:45;;;4921:1;4918;4911:12;4880:45;4971:6;4966:3;4959:4;4951:6;4947:17;4934:44;5026:1;5019:4;5010:6;5002;4998:19;4994:30;4987:41;;;;4402:632;;;;;:::o;5039:451::-;5108:6;5161:2;5149:9;5140:7;5136:23;5132:32;5129:52;;;5177:1;5174;5167:12;5129:52;5217:9;5204:23;5250:18;5242:6;5239:30;5236:50;;;5282:1;5279;5272:12;5236:50;5305:22;;5358:4;5350:13;;5346:27;-1:-1:-1;5336:55:1;;5387:1;5384;5377:12;5336:55;5410:74;5476:7;5471:2;5458:16;5453:2;5449;5445:11;5410:74;:::i;5495:167::-;5562:20;;5622:14;5611:26;;5601:37;;5591:65;;5652:1;5649;5642:12;5667:184;5725:6;5778:2;5766:9;5757:7;5753:23;5749:32;5746:52;;;5794:1;5791;5784:12;5746:52;5817:28;5835:9;5817:28;:::i;5856:258::-;5923:6;5931;5984:2;5972:9;5963:7;5959:23;5955:32;5952:52;;;6000:1;5997;5990:12;5952:52;6023:29;6042:9;6023:29;:::i;:::-;6013:39;;6071:37;6104:2;6093:9;6089:18;6071:37;:::i;6119:118::-;6205:5;6198:13;6191:21;6184:5;6181:32;6171:60;;6227:1;6224;6217:12;6242:241;6298:6;6351:2;6339:9;6330:7;6326:23;6322:32;6319:52;;;6367:1;6364;6357:12;6319:52;6406:9;6393:23;6425:28;6447:5;6425:28;:::i;6488:315::-;6553:6;6561;6614:2;6602:9;6593:7;6589:23;6585:32;6582:52;;;6630:1;6627;6620:12;6582:52;6653:29;6672:9;6653:29;:::i;:::-;6643:39;;6732:2;6721:9;6717:18;6704:32;6745:28;6767:5;6745:28;:::i;:::-;6792:5;6782:15;;;6488:315;;;;;:::o;6808:667::-;6903:6;6911;6919;6927;6980:3;6968:9;6959:7;6955:23;6951:33;6948:53;;;6997:1;6994;6987:12;6948:53;7020:29;7039:9;7020:29;:::i;:::-;7010:39;;7068:38;7102:2;7091:9;7087:18;7068:38;:::i;:::-;7058:48;;7153:2;7142:9;7138:18;7125:32;7115:42;;7208:2;7197:9;7193:18;7180:32;7235:18;7227:6;7224:30;7221:50;;;7267:1;7264;7257:12;7221:50;7290:22;;7343:4;7335:13;;7331:27;-1:-1:-1;7321:55:1;;7372:1;7369;7362:12;7321:55;7395:74;7461:7;7456:2;7443:16;7438:2;7434;7430:11;7395:74;:::i;:::-;7385:84;;;6808:667;;;;;;;:::o;7480:260::-;7548:6;7556;7609:2;7597:9;7588:7;7584:23;7580:32;7577:52;;;7625:1;7622;7615:12;7577:52;7648:29;7667:9;7648:29;:::i;:::-;7638:39;;7696:38;7730:2;7719:9;7715:18;7696:38;:::i;7745:127::-;7806:10;7801:3;7797:20;7794:1;7787:31;7837:4;7834:1;7827:15;7861:4;7858:1;7851:15;7877:127;7938:10;7933:3;7929:20;7926:1;7919:31;7969:4;7966:1;7959:15;7993:4;7990:1;7983:15;8009:135;8048:3;8069:17;;;8066:43;;8089:18;;:::i;:::-;-1:-1:-1;8136:1:1;8125:13;;8009:135::o;8149:380::-;8228:1;8224:12;;;;8271;;;8292:61;;8346:4;8338:6;8334:17;8324:27;;8292:61;8399:2;8391:6;8388:14;8368:18;8365:38;8362:161;;8445:10;8440:3;8436:20;8433:1;8426:31;8480:4;8477:1;8470:15;8508:4;8505:1;8498:15;8362:161;;8149:380;;;:::o;9774:125::-;9814:4;9842:1;9839;9836:8;9833:34;;;9847:18;;:::i;:::-;-1:-1:-1;9884:9:1;;9774:125::o;9904:422::-;9993:1;10036:5;9993:1;10050:270;10071:7;10061:8;10058:21;10050:270;;;10130:4;10126:1;10122:6;10118:17;10112:4;10109:27;10106:53;;;10139:18;;:::i;:::-;10189:7;10179:8;10175:22;10172:55;;;10209:16;;;;10172:55;10288:22;;;;10248:15;;;;10050:270;;;10054:3;9904:422;;;;;:::o;10331:806::-;10380:5;10410:8;10400:80;;-1:-1:-1;10451:1:1;10465:5;;10400:80;10499:4;10489:76;;-1:-1:-1;10536:1:1;10550:5;;10489:76;10581:4;10599:1;10594:59;;;;10667:1;10662:130;;;;10574:218;;10594:59;10624:1;10615:10;;10638:5;;;10662:130;10699:3;10689:8;10686:17;10683:43;;;10706:18;;:::i;:::-;-1:-1:-1;;10762:1:1;10748:16;;10777:5;;10574:218;;10876:2;10866:8;10863:16;10857:3;10851:4;10848:13;10844:36;10838:2;10828:8;10825:16;10820:2;10814:4;10811:12;10807:35;10804:77;10801:159;;;-1:-1:-1;10913:19:1;;;10945:5;;10801:159;10992:34;11017:8;11011:4;10992:34;:::i;:::-;11062:6;11058:1;11054:6;11050:19;11041:7;11038:32;11035:58;;;11073:18;;:::i;:::-;11111:20;;10331:806;-1:-1:-1;;;10331:806:1:o;11142:131::-;11202:5;11231:36;11258:8;11252:4;11231:36;:::i;11278:168::-;11318:7;11384:1;11380;11376:6;11372:14;11369:1;11366:21;11361:1;11354:9;11347:17;11343:45;11340:71;;;11391:18;;:::i;:::-;-1:-1:-1;11431:9:1;;11278:168::o;11451:127::-;11512:10;11507:3;11503:20;11500:1;11493:31;11543:4;11540:1;11533:15;11567:4;11564:1;11557:15;11583:120;11623:1;11649;11639:35;;11654:18;;:::i;:::-;-1:-1:-1;11688:9:1;;11583:120::o;11708:413::-;11910:2;11892:21;;;11949:2;11929:18;;;11922:30;11988:34;11983:2;11968:18;;11961:62;-1:-1:-1;;;12054:2:1;12039:18;;12032:47;12111:3;12096:19;;11708:413::o;12126:195::-;12165:1;12191:14;12232:2;12229:1;12225:10;12254:3;12244:37;;12261:18;;:::i;:::-;12299:10;;12295:20;;;;;12126:195;-1:-1:-1;;12126:195:1:o;12326:232::-;12365:3;12393:14;12434:2;12431:1;12427:10;12464:2;12461:1;12457:10;12495:3;12491:2;12487:12;12482:3;12479:21;12476:47;;;12503:18;;:::i;:::-;12539:13;;12326:232;-1:-1:-1;;;;12326:232:1:o;15328:136::-;15367:3;15395:5;15385:39;;15404:18;;:::i;:::-;-1:-1:-1;;;15440:18:1;;15328:136::o;15469:128::-;15509:3;15540:1;15536:6;15533:1;15530:13;15527:39;;;15546:18;;:::i;:::-;-1:-1:-1;15582:9:1;;15469:128::o;15911:245::-;15978:6;16031:2;16019:9;16010:7;16006:23;16002:32;15999:52;;;16047:1;16044;16037:12;15999:52;16079:9;16073:16;16098:28;16120:5;16098:28;:::i;17739:414::-;17941:2;17923:21;;;17980:2;17960:18;;;17953:30;18019:34;18014:2;17999:18;;17992:62;-1:-1:-1;;;18085:2:1;18070:18;;18063:48;18143:3;18128:19;;17739:414::o;18574:470::-;18753:3;18791:6;18785:13;18807:53;18853:6;18848:3;18841:4;18833:6;18829:17;18807:53;:::i;:::-;18923:13;;18882:16;;;;18945:57;18923:13;18882:16;18979:4;18967:17;;18945:57;:::i;19789:112::-;19821:1;19847;19837:35;;19852:18;;:::i;:::-;-1:-1:-1;19886:9:1;;19789:112::o;19906:489::-;-1:-1:-1;;;;;20175:15:1;;;20157:34;;20227:15;;20222:2;20207:18;;20200:43;20274:2;20259:18;;20252:34;;;20322:3;20317:2;20302:18;;20295:31;;;20100:4;;20343:46;;20369:19;;20361:6;20343:46;:::i;:::-;20335:54;19906:489;-1:-1:-1;;;;;;19906:489:1:o;20400:249::-;20469:6;20522:2;20510:9;20501:7;20497:23;20493:32;20490:52;;;20538:1;20535;20528:12;20490:52;20570:9;20564:16;20589:30;20613:5;20589:30;:::i

Swarm Source

ipfs://cedc845fc775eb60e92a1608f78d059ce273709c959ae55cc3539af78870d897

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