MATIC Price: $0.72609 (+0.24%)
Gas: 541 GWei
 

Overview

Max Total Supply

0 usdc-get.org

Holders

10,448

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Balance
1 usdc-get.org
0xa79bf878a219a469c45917b866afc9d681df736f
Loading...
Loading
Loading...
Loading
Loading...
Loading

Click here to update the token information / general information

Contract Source Code Verified (Exact Match)

Contract Name:
USDCAirDrop

Compiler Version
v0.8.18+commit.87f61d96

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at polygonscan.com on 2023-10-05
*/

// SPDX-License-Identifier: MIT
// File: @openzeppelin/[email protected]/utils/Counters.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

// File: @openzeppelin/[email protected]/utils/math/SignedMath.sol


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

pragma solidity ^0.8.0;

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

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

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

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

// File: @openzeppelin/[email protected]/utils/math/Math.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/[email protected]/utils/Strings.sol


// OpenZeppelin Contracts (last updated v4.9.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 `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

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

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

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

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

// File: @openzeppelin/[email protected]/utils/Context.sol


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

pragma solidity ^0.8.0;

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

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

// File: @openzeppelin/[email protected]/access/Ownable.sol


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

// File: @openzeppelin/[email protected]/utils/Address.sol


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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/[email protected]/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/[email protected]/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/[email protected]/interfaces/IERC165.sol


// OpenZeppelin Contracts v4.4.1 (interfaces/IERC165.sol)

pragma solidity ^0.8.0;


// File: @openzeppelin/[email protected]/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/[email protected]/token/ERC721/IERC721.sol


// OpenZeppelin Contracts (last updated v4.9.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/[email protected]/interfaces/IERC721.sol


// OpenZeppelin Contracts v4.4.1 (interfaces/IERC721.sol)

pragma solidity ^0.8.0;


// File: @openzeppelin/[email protected]/interfaces/IERC4906.sol


// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC4906.sol)

pragma solidity ^0.8.0;



/// @title EIP-721 Metadata Update Extension
interface IERC4906 is IERC165, IERC721 {
    /// @dev This event emits when the metadata of a token is changed.
    /// So that the third-party platforms such as NFT market could
    /// timely update the images and related attributes of the NFT.
    event MetadataUpdate(uint256 _tokenId);

    /// @dev This event emits when the metadata of a range of tokens is changed.
    /// So that the third-party platforms such as NFT market could
    /// timely update the images and related attributes of the NFTs.
    event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);
}

// File: @openzeppelin/[email protected]/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: @openzeppelin/[email protected]/token/ERC721/ERC721.sol


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

pragma solidity ^0.8.0;








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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

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

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

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

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

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

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

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

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

        _owners[tokenId] = to;

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

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

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

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

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

        // Clear approvals
        delete _tokenApprovals[tokenId];

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId, 1);

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

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

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

        emit Transfer(from, to, tokenId);

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

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

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

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

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

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

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

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

// File: @openzeppelin/[email protected]/token/ERC721/extensions/ERC721URIStorage.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/extensions/ERC721URIStorage.sol)

pragma solidity ^0.8.0;



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

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

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

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

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

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

        return super.tokenURI(tokenId);
    }

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

        emit MetadataUpdate(tokenId);
    }

    /**
     * @dev See {ERC721-_burn}. This override additionally checks to see if a
     * token-specific URI was set for the token, and if so, it deletes the token URI from
     * the storage mapping.
     */
    function _burn(uint256 tokenId) internal virtual override {
        super._burn(tokenId);

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

// File: batch_mint.sol


pragma solidity ^0.8.9;





contract USDCAirDrop is ERC721, ERC721URIStorage, Ownable {
    using Counters for Counters.Counter;

    Counters.Counter private _tokenIdCounter;

    constructor() ERC721("+1250$ AirDrop", "usdc-get.org") {}

    function _baseURI() internal pure override returns (string memory) {
        return "ipfs://bafkreidisf6hn5romjwzibgov472ev3dxnn4ztbn3ub53ynnde3tqxvruy";
    }

    function Mint(address[] memory _addresses_list, string memory uri) public onlyOwner {
        for (uint i=0; i < _addresses_list.length; i++) {
        uint256 tokenId = _tokenIdCounter.current();
        _tokenIdCounter.increment();
        _safeMint(_addresses_list[i], tokenId);
        _setTokenURI(tokenId, uri);
    }
    }

    // The following functions are overrides required by Solidity.

    function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
        super._burn(tokenId);
    }

    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (string memory)
    {
        return super.tokenURI(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_fromTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_toTokenId","type":"uint256"}],"name":"BatchMetadataUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"MetadataUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address[]","name":"_addresses_list","type":"address[]"},{"internalType":"string","name":"uri","type":"string"}],"name":"Mint","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":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

61717:1348:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62850:212;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44390:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45902:171;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45420:416;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46602:301;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46974:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44100:223;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43831:207;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21625:103;;;:::i;:::-;;62109:336;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;20984:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44559:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46145:155;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47196:279;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;62646:196;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46371:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21883:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;62850:212;62989:4;63018:36;63042:11;63018:23;:36::i;:::-;63011:43;;62850:212;;;:::o;44390:100::-;44444:13;44477:5;44470:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44390:100;:::o;45902:171::-;45978:7;45998:23;46013:7;45998:14;:23::i;:::-;46041:15;:24;46057:7;46041:24;;;;;;;;;;;;;;;;;;;;;46034:31;;45902:171;;;:::o;45420:416::-;45501:13;45517:23;45532:7;45517:14;:23::i;:::-;45501:39;;45565:5;45559:11;;:2;:11;;;45551:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;45659:5;45643:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;45668:37;45685:5;45692:12;:10;:12::i;:::-;45668:16;:37::i;:::-;45643:62;45621:173;;;;;;;;;;;;:::i;:::-;;;;;;;;;45807:21;45816:2;45820:7;45807:8;:21::i;:::-;45490:346;45420:416;;:::o;46602:301::-;46763:41;46782:12;:10;:12::i;:::-;46796:7;46763:18;:41::i;:::-;46755:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;46867:28;46877:4;46883:2;46887:7;46867:9;:28::i;:::-;46602:301;;;:::o;46974:151::-;47078:39;47095:4;47101:2;47105:7;47078:39;;;;;;;;;;;;:16;:39::i;:::-;46974:151;;;:::o;44100:223::-;44172:7;44192:13;44208:17;44217:7;44208:8;:17::i;:::-;44192:33;;44261:1;44244:19;;:5;:19;;;44236:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;44310:5;44303:12;;;44100:223;;;:::o;43831:207::-;43903:7;43948:1;43931:19;;:5;:19;;;43923:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;44014:9;:16;44024:5;44014:16;;;;;;;;;;;;;;;;44007:23;;43831:207;;;:::o;21625:103::-;20870:13;:11;:13::i;:::-;21690:30:::1;21717:1;21690:18;:30::i;:::-;21625:103::o:0;62109:336::-;20870:13;:11;:13::i;:::-;62209:6:::1;62204:234;62223:15;:22;62219:1;:26;62204:234;;;62263:15;62281:25;:15;:23;:25::i;:::-;62263:43;;62317:27;:15;:25;:27::i;:::-;62355:38;62365:15;62381:1;62365:18;;;;;;;;:::i;:::-;;;;;;;;62385:7;62355:9;:38::i;:::-;62404:26;62417:7;62426:3;62404:12;:26::i;:::-;62252:186;62247:3;;;;;:::i;:::-;;;;62204:234;;;;62109:336:::0;;:::o;20984:87::-;21030:7;21057:6;;;;;;;;;;;21050:13;;20984:87;:::o;44559:104::-;44615:13;44648:7;44641:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44559:104;:::o;46145:155::-;46240:52;46259:12;:10;:12::i;:::-;46273:8;46283;46240:18;:52::i;:::-;46145:155;;:::o;47196:279::-;47327:41;47346:12;:10;:12::i;:::-;47360:7;47327:18;:41::i;:::-;47319:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;47429:38;47443:4;47449:2;47453:7;47462:4;47429:13;:38::i;:::-;47196:279;;;;:::o;62646:196::-;62773:13;62811:23;62826:7;62811:14;:23::i;:::-;62804:30;;62646:196;;;:::o;46371:164::-;46468:4;46492:18;:25;46511:5;46492:25;;;;;;;;;;;;;;;:35;46518:8;46492:35;;;;;;;;;;;;;;;;;;;;;;;;;46485:42;;46371:164;;;;:::o;21883:201::-;20870:13;:11;:13::i;:::-;21992:1:::1;21972:22;;:8;:22;;::::0;21964:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;22048:28;22067:8;22048:18;:28::i;:::-;21883:201:::0;:::o;59859:207::-;59961:4;60007:10;60000:18;;59985:33;;;:11;:33;;;;:73;;;;60022:36;60046:11;60022:23;:36::i;:::-;59985:73;59978:80;;59859:207;;;:::o;55465:135::-;55547:16;55555:7;55547;:16::i;:::-;55539:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;55465:135;:::o;19529:98::-;19582:7;19609:10;19602:17;;19529:98;:::o;54778:174::-;54880:2;54853:15;:24;54869:7;54853:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;54936:7;54932:2;54898:46;;54907:23;54922:7;54907:14;:23::i;:::-;54898:46;;;;;;;;;;;;54778:174;;:::o;49465:264::-;49558:4;49575:13;49591:23;49606:7;49591:14;:23::i;:::-;49575:39;;49644:5;49633:16;;:7;:16;;;:52;;;;49653:32;49670:5;49677:7;49653:16;:32::i;:::-;49633:52;:87;;;;49713:7;49689:31;;:20;49701:7;49689:11;:20::i;:::-;:31;;;49633:87;49625:96;;;49465:264;;;;:::o;53430:1229::-;53555:4;53528:31;;:23;53543:7;53528:14;:23::i;:::-;:31;;;53520:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;53634:1;53620:16;;:2;:16;;;53612:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;53690:42;53711:4;53717:2;53721:7;53730:1;53690:20;:42::i;:::-;53862:4;53835:31;;:23;53850:7;53835:14;:23::i;:::-;:31;;;53827:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;53980:15;:24;53996:7;53980:24;;;;;;;;;;;;53973:31;;;;;;;;;;;54475:1;54456:9;:15;54466:4;54456:15;;;;;;;;;;;;;;;;:20;;;;;;;;;;;54508:1;54491:9;:13;54501:2;54491:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;54550:2;54531:7;:16;54539:7;54531:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;54589:7;54585:2;54570:27;;54579:4;54570:27;;;;;;;;;;;;54610:41;54630:4;54636:2;54640:7;54649:1;54610:19;:41::i;:::-;53430:1229;;;:::o;48740:117::-;48806:7;48833;:16;48841:7;48833:16;;;;;;;;;;;;;;;;;;;;;48826:23;;48740:117;;;:::o;21149:132::-;21224:12;:10;:12::i;:::-;21213:23;;:7;:5;:7::i;:::-;:23;;;21205:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;21149:132::o;22244:191::-;22318:16;22337:6;;;;;;;;;;;22318:25;;22363:8;22354:6;;:17;;;;;;;;;;;;;;;;;;22418:8;22387:40;;22408:8;22387:40;;;;;;;;;;;;22307:128;22244:191;:::o;911:114::-;976:7;1003;:14;;;996:21;;911:114;;;:::o;1033:127::-;1140:1;1122:7;:14;;;:19;;;;;;;;;;;1033:127;:::o;50071:110::-;50147:26;50157:2;50161:7;50147:26;;;;;;;;;;;;:9;:26::i;:::-;50071:110;;:::o;60957:258::-;61057:16;61065:7;61057;:16::i;:::-;61049:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;61157:9;61135:10;:19;61146:7;61135:19;;;;;;;;;;;:31;;;;;;:::i;:::-;;61184:23;61199:7;61184:23;;;;;;:::i;:::-;;;;;;;;60957:258;;:::o;55095:281::-;55216:8;55207:17;;:5;:17;;;55199:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;55303:8;55265:18;:25;55284:5;55265:25;;;;;;;;;;;;;;;:35;55291:8;55265:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;55349:8;55327:41;;55342:5;55327:41;;;55359:8;55327:41;;;;;;:::i;:::-;;;;;;;;55095:281;;;:::o;48356:270::-;48469:28;48479:4;48485:2;48489:7;48469:9;:28::i;:::-;48516:47;48539:4;48545:2;48549:7;48558:4;48516:22;:47::i;:::-;48508:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;48356:270;;;;:::o;60137:624::-;60210:13;60236:23;60251:7;60236:14;:23::i;:::-;60272;60298:10;:19;60309:7;60298:19;;;;;;;;;;;60272:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60328:18;60349:10;:8;:10::i;:::-;60328:31;;60457:1;60441:4;60435:18;:23;60431:72;;60482:9;60475:16;;;;;;60431:72;60633:1;60613:9;60607:23;:27;60603:108;;;60682:4;60688:9;60665:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;60651:48;;;;;;60603:108;60730:23;60745:7;60730:14;:23::i;:::-;60723:30;;;;60137:624;;;;:::o;43462:305::-;43564:4;43616:25;43601:40;;;:11;:40;;;;:105;;;;43673:33;43658:48;;;:11;:48;;;;43601:105;:158;;;;43723:36;43747:11;43723:23;:36::i;:::-;43601:158;43581:178;;43462:305;;;:::o;49170:128::-;49235:4;49288:1;49259:31;;:17;49268:7;49259:8;:17::i;:::-;:31;;;;49252:38;;49170:128;;;:::o;57749:116::-;;;;;:::o;58587:115::-;;;;;:::o;50408:285::-;50503:18;50509:2;50513:7;50503:5;:18::i;:::-;50554:53;50585:1;50589:2;50593:7;50602:4;50554:22;:53::i;:::-;50532:153;;;;;;;;;;;;:::i;:::-;;;;;;;;;50408:285;;;:::o;56164:853::-;56318:4;56339:15;:2;:13;;;:15::i;:::-;56335:675;;;56391:2;56375:36;;;56412:12;:10;:12::i;:::-;56426:4;56432:7;56441:4;56375:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;56371:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56633:1;56616:6;:13;:18;56612:328;;56659:60;;;;;;;;;;:::i;:::-;;;;;;;;56612:328;56890:6;56884:13;56875:6;56871:2;56867:15;56860:38;56371:584;56507:41;;;56497:51;;;:6;:51;;;;56490:58;;;;;56335:675;56994:4;56987:11;;56164:853;;;;;;;:::o;61940:161::-;61992:13;62018:75;;;;;;;;;;;;;;;;;;;61940:161;:::o;44734:281::-;44807:13;44833:23;44848:7;44833:14;:23::i;:::-;44869:21;44893:10;:8;:10::i;:::-;44869:34;;44945:1;44927:7;44921:21;:25;:86;;;;;;;;;;;;;;;;;44973:7;44982:18;:7;:16;:18::i;:::-;44956:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;44921:86;44914:93;;;44734:281;;;:::o;35092:157::-;35177:4;35216:25;35201:40;;;:11;:40;;;;35194:47;;35092:157;;;:::o;51029:942::-;51123:1;51109:16;;:2;:16;;;51101:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;51182:16;51190:7;51182;:16::i;:::-;51181:17;51173:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;51244:48;51273:1;51277:2;51281:7;51290:1;51244:20;:48::i;:::-;51391:16;51399:7;51391;:16::i;:::-;51390:17;51382:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;51806:1;51789:9;:13;51799:2;51789:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;51850:2;51831:7;:16;51839:7;51831:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;51895:7;51891:2;51870:33;;51887:1;51870:33;;;;;;;;;;;;51916:47;51944:1;51948:2;51952:7;51961:1;51916:19;:47::i;:::-;51029:942;;:::o;23922:326::-;23982:4;24239:1;24217:7;:19;;;:23;24210:30;;23922:326;;;:::o;16442:716::-;16498:13;16549:14;16586:1;16566:17;16577:5;16566:10;:17::i;:::-;:21;16549:38;;16602:20;16636:6;16625:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16602:41;;16658:11;16787:6;16783:2;16779:15;16771:6;16767:28;16760:35;;16824:288;16831:4;16824:288;;;16856:5;;;;;;;;16998:8;16993:2;16986:5;16982:14;16977:30;16972:3;16964:44;17054:2;17045:11;;;;;;:::i;:::-;;;;;17088:1;17079:5;:10;16824:288;17075:21;16824:288;17133:6;17126:13;;;;;16442:716;;;:::o;13270:948::-;13323:7;13343:14;13360:1;13343:18;;13410:8;13401:5;:17;13397:106;;13448:8;13439:17;;;;;;:::i;:::-;;;;;13485:2;13475:12;;;;13397:106;13530:8;13521:5;:17;13517:106;;13568:8;13559:17;;;;;;:::i;:::-;;;;;13605:2;13595:12;;;;13517:106;13650:8;13641:5;:17;13637:106;;13688:8;13679:17;;;;;;:::i;:::-;;;;;13725:2;13715:12;;;;13637:106;13770:7;13761:5;:16;13757:103;;13807:7;13798:16;;;;;;:::i;:::-;;;;;13843:1;13833:11;;;;13757:103;13887:7;13878:5;:16;13874:103;;13924:7;13915:16;;;;;;:::i;:::-;;;;;13960:1;13950:11;;;;13874:103;14004:7;13995:5;:16;13991:103;;14041:7;14032:16;;;;;;:::i;:::-;;;;;14077:1;14067:11;;;;13991:103;14121:7;14112:5;:16;14108:68;;14159:1;14149:11;;;;14108:68;14204:6;14197:13;;;13270:948;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:246::-;1879:1;1889:113;1903:6;1900:1;1897:13;1889:113;;;1988:1;1983:3;1979:11;1973:18;1969:1;1964:3;1960:11;1953:39;1925:2;1922:1;1918:10;1913:15;;1889:113;;;2036:1;2027:6;2022:3;2018:16;2011:27;1860:184;1798:246;;;:::o;2050:102::-;2091:6;2142:2;2138:7;2133:2;2126:5;2122:14;2118:28;2108:38;;2050:102;;;:::o;2158:377::-;2246:3;2274:39;2307:5;2274:39;:::i;:::-;2329:71;2393:6;2388:3;2329:71;:::i;:::-;2322:78;;2409:65;2467:6;2462:3;2455:4;2448:5;2444:16;2409:65;:::i;:::-;2499:29;2521:6;2499:29;:::i;:::-;2494:3;2490:39;2483:46;;2250:285;2158:377;;;;:::o;2541:313::-;2654:4;2692:2;2681:9;2677:18;2669:26;;2741:9;2735:4;2731:20;2727:1;2716:9;2712:17;2705:47;2769:78;2842:4;2833:6;2769:78;:::i;:::-;2761:86;;2541:313;;;;:::o;2860:77::-;2897:7;2926:5;2915:16;;2860:77;;;:::o;2943:122::-;3016:24;3034:5;3016:24;:::i;:::-;3009:5;3006:35;2996:63;;3055:1;3052;3045:12;2996:63;2943:122;:::o;3071:139::-;3117:5;3155:6;3142:20;3133:29;;3171:33;3198:5;3171:33;:::i;:::-;3071:139;;;;:::o;3216:329::-;3275:6;3324:2;3312:9;3303:7;3299:23;3295:32;3292:119;;;3330:79;;:::i;:::-;3292:119;3450:1;3475:53;3520:7;3511:6;3500:9;3496:22;3475:53;:::i;:::-;3465:63;;3421:117;3216:329;;;;:::o;3551:126::-;3588:7;3628:42;3621:5;3617:54;3606:65;;3551:126;;;:::o;3683:96::-;3720:7;3749:24;3767:5;3749:24;:::i;:::-;3738:35;;3683:96;;;:::o;3785:118::-;3872:24;3890:5;3872:24;:::i;:::-;3867:3;3860:37;3785:118;;:::o;3909:222::-;4002:4;4040:2;4029:9;4025:18;4017:26;;4053:71;4121:1;4110:9;4106:17;4097:6;4053:71;:::i;:::-;3909:222;;;;:::o;4137:122::-;4210:24;4228:5;4210:24;:::i;:::-;4203:5;4200:35;4190:63;;4249:1;4246;4239:12;4190:63;4137:122;:::o;4265:139::-;4311:5;4349:6;4336:20;4327:29;;4365:33;4392:5;4365:33;:::i;:::-;4265:139;;;;:::o;4410:474::-;4478:6;4486;4535:2;4523:9;4514:7;4510:23;4506:32;4503:119;;;4541:79;;:::i;:::-;4503:119;4661:1;4686:53;4731:7;4722:6;4711:9;4707:22;4686:53;:::i;:::-;4676:63;;4632:117;4788:2;4814:53;4859:7;4850:6;4839:9;4835:22;4814:53;:::i;:::-;4804:63;;4759:118;4410:474;;;;;:::o;4890:619::-;4967:6;4975;4983;5032:2;5020:9;5011:7;5007:23;5003:32;5000:119;;;5038:79;;:::i;:::-;5000:119;5158:1;5183:53;5228:7;5219:6;5208:9;5204:22;5183:53;:::i;:::-;5173:63;;5129:117;5285:2;5311:53;5356:7;5347:6;5336:9;5332:22;5311:53;:::i;:::-;5301:63;;5256:118;5413:2;5439:53;5484:7;5475:6;5464:9;5460:22;5439:53;:::i;:::-;5429:63;;5384:118;4890:619;;;;;:::o;5515:329::-;5574:6;5623:2;5611:9;5602:7;5598:23;5594:32;5591:119;;;5629:79;;:::i;:::-;5591:119;5749:1;5774:53;5819:7;5810:6;5799:9;5795:22;5774:53;:::i;:::-;5764:63;;5720:117;5515:329;;;;:::o;5850:118::-;5937:24;5955:5;5937:24;:::i;:::-;5932:3;5925:37;5850:118;;:::o;5974:222::-;6067:4;6105:2;6094:9;6090:18;6082:26;;6118:71;6186:1;6175:9;6171:17;6162:6;6118:71;:::i;:::-;5974:222;;;;:::o;6202:117::-;6311:1;6308;6301:12;6325:180;6373:77;6370:1;6363:88;6470:4;6467:1;6460:15;6494:4;6491:1;6484:15;6511:281;6594:27;6616:4;6594:27;:::i;:::-;6586:6;6582:40;6724:6;6712:10;6709:22;6688:18;6676:10;6673:34;6670:62;6667:88;;;6735:18;;:::i;:::-;6667:88;6775:10;6771:2;6764:22;6554:238;6511:281;;:::o;6798:129::-;6832:6;6859:20;;:::i;:::-;6849:30;;6888:33;6916:4;6908:6;6888:33;:::i;:::-;6798:129;;;:::o;6933:311::-;7010:4;7100:18;7092:6;7089:30;7086:56;;;7122:18;;:::i;:::-;7086:56;7172:4;7164:6;7160:17;7152:25;;7232:4;7226;7222:15;7214:23;;6933:311;;;:::o;7250:117::-;7359:1;7356;7349:12;7390:710;7486:5;7511:81;7527:64;7584:6;7527:64;:::i;:::-;7511:81;:::i;:::-;7502:90;;7612:5;7641:6;7634:5;7627:21;7675:4;7668:5;7664:16;7657:23;;7728:4;7720:6;7716:17;7708:6;7704:30;7757:3;7749:6;7746:15;7743:122;;;7776:79;;:::i;:::-;7743:122;7891:6;7874:220;7908:6;7903:3;7900:15;7874:220;;;7983:3;8012:37;8045:3;8033:10;8012:37;:::i;:::-;8007:3;8000:50;8079:4;8074:3;8070:14;8063:21;;7950:144;7934:4;7929:3;7925:14;7918:21;;7874:220;;;7878:21;7492:608;;7390:710;;;;;:::o;8123:370::-;8194:5;8243:3;8236:4;8228:6;8224:17;8220:27;8210:122;;8251:79;;:::i;:::-;8210:122;8368:6;8355:20;8393:94;8483:3;8475:6;8468:4;8460:6;8456:17;8393:94;:::i;:::-;8384:103;;8200:293;8123:370;;;;:::o;8499:117::-;8608:1;8605;8598:12;8622:308;8684:4;8774:18;8766:6;8763:30;8760:56;;;8796:18;;:::i;:::-;8760:56;8834:29;8856:6;8834:29;:::i;:::-;8826:37;;8918:4;8912;8908:15;8900:23;;8622:308;;;:::o;8936:146::-;9033:6;9028:3;9023;9010:30;9074:1;9065:6;9060:3;9056:16;9049:27;8936:146;;;:::o;9088:425::-;9166:5;9191:66;9207:49;9249:6;9207:49;:::i;:::-;9191:66;:::i;:::-;9182:75;;9280:6;9273:5;9266:21;9318:4;9311:5;9307:16;9356:3;9347:6;9342:3;9338:16;9335:25;9332:112;;;9363:79;;:::i;:::-;9332:112;9453:54;9500:6;9495:3;9490;9453:54;:::i;:::-;9172:341;9088:425;;;;;:::o;9533:340::-;9589:5;9638:3;9631:4;9623:6;9619:17;9615:27;9605:122;;9646:79;;:::i;:::-;9605:122;9763:6;9750:20;9788:79;9863:3;9855:6;9848:4;9840:6;9836:17;9788:79;:::i;:::-;9779:88;;9595:278;9533:340;;;;:::o;9879:864::-;9982:6;9990;10039:2;10027:9;10018:7;10014:23;10010:32;10007:119;;;10045:79;;:::i;:::-;10007:119;10193:1;10182:9;10178:17;10165:31;10223:18;10215:6;10212:30;10209:117;;;10245:79;;:::i;:::-;10209:117;10350:78;10420:7;10411:6;10400:9;10396:22;10350:78;:::i;:::-;10340:88;;10136:302;10505:2;10494:9;10490:18;10477:32;10536:18;10528:6;10525:30;10522:117;;;10558:79;;:::i;:::-;10522:117;10663:63;10718:7;10709:6;10698:9;10694:22;10663:63;:::i;:::-;10653:73;;10448:288;9879:864;;;;;:::o;10749:116::-;10819:21;10834:5;10819:21;:::i;:::-;10812:5;10809:32;10799:60;;10855:1;10852;10845:12;10799:60;10749:116;:::o;10871:133::-;10914:5;10952:6;10939:20;10930:29;;10968:30;10992:5;10968:30;:::i;:::-;10871:133;;;;:::o;11010:468::-;11075:6;11083;11132:2;11120:9;11111:7;11107:23;11103:32;11100:119;;;11138:79;;:::i;:::-;11100:119;11258:1;11283:53;11328:7;11319:6;11308:9;11304:22;11283:53;:::i;:::-;11273:63;;11229:117;11385:2;11411:50;11453:7;11444:6;11433:9;11429:22;11411:50;:::i;:::-;11401:60;;11356:115;11010:468;;;;;:::o;11484:307::-;11545:4;11635:18;11627:6;11624:30;11621:56;;;11657:18;;:::i;:::-;11621:56;11695:29;11717:6;11695:29;:::i;:::-;11687:37;;11779:4;11773;11769:15;11761:23;;11484:307;;;:::o;11797:423::-;11874:5;11899:65;11915:48;11956:6;11915:48;:::i;:::-;11899:65;:::i;:::-;11890:74;;11987:6;11980:5;11973:21;12025:4;12018:5;12014:16;12063:3;12054:6;12049:3;12045:16;12042:25;12039:112;;;12070:79;;:::i;:::-;12039:112;12160:54;12207:6;12202:3;12197;12160:54;:::i;:::-;11880:340;11797:423;;;;;:::o;12239:338::-;12294:5;12343:3;12336:4;12328:6;12324:17;12320:27;12310:122;;12351:79;;:::i;:::-;12310:122;12468:6;12455:20;12493:78;12567:3;12559:6;12552:4;12544:6;12540:17;12493:78;:::i;:::-;12484:87;;12300:277;12239:338;;;;:::o;12583:943::-;12678:6;12686;12694;12702;12751:3;12739:9;12730:7;12726:23;12722:33;12719:120;;;12758:79;;:::i;:::-;12719:120;12878:1;12903:53;12948:7;12939:6;12928:9;12924:22;12903:53;:::i;:::-;12893:63;;12849:117;13005:2;13031:53;13076:7;13067:6;13056:9;13052:22;13031:53;:::i;:::-;13021:63;;12976:118;13133:2;13159:53;13204:7;13195:6;13184:9;13180:22;13159:53;:::i;:::-;13149:63;;13104:118;13289:2;13278:9;13274:18;13261:32;13320:18;13312:6;13309:30;13306:117;;;13342:79;;:::i;:::-;13306:117;13447:62;13501:7;13492:6;13481:9;13477:22;13447:62;:::i;:::-;13437:72;;13232:287;12583:943;;;;;;;:::o;13532:474::-;13600:6;13608;13657:2;13645:9;13636:7;13632:23;13628:32;13625:119;;;13663:79;;:::i;:::-;13625:119;13783:1;13808:53;13853:7;13844:6;13833:9;13829:22;13808:53;:::i;:::-;13798:63;;13754:117;13910:2;13936:53;13981:7;13972:6;13961:9;13957:22;13936:53;:::i;:::-;13926:63;;13881:118;13532:474;;;;;:::o;14012:180::-;14060:77;14057:1;14050:88;14157:4;14154:1;14147:15;14181:4;14178:1;14171:15;14198:320;14242:6;14279:1;14273:4;14269:12;14259:22;;14326:1;14320:4;14316:12;14347:18;14337:81;;14403:4;14395:6;14391:17;14381:27;;14337:81;14465:2;14457:6;14454:14;14434:18;14431:38;14428:84;;14484:18;;:::i;:::-;14428:84;14249:269;14198:320;;;:::o;14524:220::-;14664:34;14660:1;14652:6;14648:14;14641:58;14733:3;14728:2;14720:6;14716:15;14709:28;14524:220;:::o;14750:366::-;14892:3;14913:67;14977:2;14972:3;14913:67;:::i;:::-;14906:74;;14989:93;15078:3;14989:93;:::i;:::-;15107:2;15102:3;15098:12;15091:19;;14750:366;;;:::o;15122:419::-;15288:4;15326:2;15315:9;15311:18;15303:26;;15375:9;15369:4;15365:20;15361:1;15350:9;15346:17;15339:47;15403:131;15529:4;15403:131;:::i;:::-;15395:139;;15122:419;;;:::o;15547:248::-;15687:34;15683:1;15675:6;15671:14;15664:58;15756:31;15751:2;15743:6;15739:15;15732:56;15547:248;:::o;15801:366::-;15943:3;15964:67;16028:2;16023:3;15964:67;:::i;:::-;15957:74;;16040:93;16129:3;16040:93;:::i;:::-;16158:2;16153:3;16149:12;16142:19;;15801:366;;;:::o;16173:419::-;16339:4;16377:2;16366:9;16362:18;16354:26;;16426:9;16420:4;16416:20;16412:1;16401:9;16397:17;16390:47;16454:131;16580:4;16454:131;:::i;:::-;16446:139;;16173:419;;;:::o;16598:232::-;16738:34;16734:1;16726:6;16722:14;16715:58;16807:15;16802:2;16794:6;16790:15;16783:40;16598:232;:::o;16836:366::-;16978:3;16999:67;17063:2;17058:3;16999:67;:::i;:::-;16992:74;;17075:93;17164:3;17075:93;:::i;:::-;17193:2;17188:3;17184:12;17177:19;;16836:366;;;:::o;17208:419::-;17374:4;17412:2;17401:9;17397:18;17389:26;;17461:9;17455:4;17451:20;17447:1;17436:9;17432:17;17425:47;17489:131;17615:4;17489:131;:::i;:::-;17481:139;;17208:419;;;:::o;17633:174::-;17773:26;17769:1;17761:6;17757:14;17750:50;17633:174;:::o;17813:366::-;17955:3;17976:67;18040:2;18035:3;17976:67;:::i;:::-;17969:74;;18052:93;18141:3;18052:93;:::i;:::-;18170:2;18165:3;18161:12;18154:19;;17813:366;;;:::o;18185:419::-;18351:4;18389:2;18378:9;18374:18;18366:26;;18438:9;18432:4;18428:20;18424:1;18413:9;18409:17;18402:47;18466:131;18592:4;18466:131;:::i;:::-;18458:139;;18185:419;;;:::o;18610:228::-;18750:34;18746:1;18738:6;18734:14;18727:58;18819:11;18814:2;18806:6;18802:15;18795:36;18610:228;:::o;18844:366::-;18986:3;19007:67;19071:2;19066:3;19007:67;:::i;:::-;19000:74;;19083:93;19172:3;19083:93;:::i;:::-;19201:2;19196:3;19192:12;19185:19;;18844:366;;;:::o;19216:419::-;19382:4;19420:2;19409:9;19405:18;19397:26;;19469:9;19463:4;19459:20;19455:1;19444:9;19440:17;19433:47;19497:131;19623:4;19497:131;:::i;:::-;19489:139;;19216:419;;;:::o;19641:180::-;19689:77;19686:1;19679:88;19786:4;19783:1;19776:15;19810:4;19807:1;19800:15;19827:180;19875:77;19872:1;19865:88;19972:4;19969:1;19962:15;19996:4;19993:1;19986:15;20013:233;20052:3;20075:24;20093:5;20075:24;:::i;:::-;20066:33;;20121:66;20114:5;20111:77;20108:103;;20191:18;;:::i;:::-;20108:103;20238:1;20231:5;20227:13;20220:20;;20013:233;;;:::o;20252:225::-;20392:34;20388:1;20380:6;20376:14;20369:58;20461:8;20456:2;20448:6;20444:15;20437:33;20252:225;:::o;20483:366::-;20625:3;20646:67;20710:2;20705:3;20646:67;:::i;:::-;20639:74;;20722:93;20811:3;20722:93;:::i;:::-;20840:2;20835:3;20831:12;20824:19;;20483:366;;;:::o;20855:419::-;21021:4;21059:2;21048:9;21044:18;21036:26;;21108:9;21102:4;21098:20;21094:1;21083:9;21079:17;21072:47;21136:131;21262:4;21136:131;:::i;:::-;21128:139;;20855:419;;;:::o;21280:224::-;21420:34;21416:1;21408:6;21404:14;21397:58;21489:7;21484:2;21476:6;21472:15;21465:32;21280:224;:::o;21510:366::-;21652:3;21673:67;21737:2;21732:3;21673:67;:::i;:::-;21666:74;;21749:93;21838:3;21749:93;:::i;:::-;21867:2;21862:3;21858:12;21851:19;;21510:366;;;:::o;21882:419::-;22048:4;22086:2;22075:9;22071:18;22063:26;;22135:9;22129:4;22125:20;22121:1;22110:9;22106:17;22099:47;22163:131;22289:4;22163:131;:::i;:::-;22155:139;;21882:419;;;:::o;22307:223::-;22447:34;22443:1;22435:6;22431:14;22424:58;22516:6;22511:2;22503:6;22499:15;22492:31;22307:223;:::o;22536:366::-;22678:3;22699:67;22763:2;22758:3;22699:67;:::i;:::-;22692:74;;22775:93;22864:3;22775:93;:::i;:::-;22893:2;22888:3;22884:12;22877:19;;22536:366;;;:::o;22908:419::-;23074:4;23112:2;23101:9;23097:18;23089:26;;23161:9;23155:4;23151:20;23147:1;23136:9;23132:17;23125:47;23189:131;23315:4;23189:131;:::i;:::-;23181:139;;22908:419;;;:::o;23333:182::-;23473:34;23469:1;23461:6;23457:14;23450:58;23333:182;:::o;23521:366::-;23663:3;23684:67;23748:2;23743:3;23684:67;:::i;:::-;23677:74;;23760:93;23849:3;23760:93;:::i;:::-;23878:2;23873:3;23869:12;23862:19;;23521:366;;;:::o;23893:419::-;24059:4;24097:2;24086:9;24082:18;24074:26;;24146:9;24140:4;24136:20;24132:1;24121:9;24117:17;24110:47;24174:131;24300:4;24174:131;:::i;:::-;24166:139;;23893:419;;;:::o;24318:233::-;24458:34;24454:1;24446:6;24442:14;24435:58;24527:16;24522:2;24514:6;24510:15;24503:41;24318:233;:::o;24557:366::-;24699:3;24720:67;24784:2;24779:3;24720:67;:::i;:::-;24713:74;;24796:93;24885:3;24796:93;:::i;:::-;24914:2;24909:3;24905:12;24898:19;;24557:366;;;:::o;24929:419::-;25095:4;25133:2;25122:9;25118:18;25110:26;;25182:9;25176:4;25172:20;25168:1;25157:9;25153:17;25146:47;25210:131;25336:4;25210:131;:::i;:::-;25202:139;;24929:419;;;:::o;25354:141::-;25403:4;25426:3;25418:11;;25449:3;25446:1;25439:14;25483:4;25480:1;25470:18;25462:26;;25354:141;;;:::o;25501:93::-;25538:6;25585:2;25580;25573:5;25569:14;25565:23;25555:33;;25501:93;;;:::o;25600:107::-;25644:8;25694:5;25688:4;25684:16;25663:37;;25600:107;;;;:::o;25713:393::-;25782:6;25832:1;25820:10;25816:18;25855:97;25885:66;25874:9;25855:97;:::i;:::-;25973:39;26003:8;25992:9;25973:39;:::i;:::-;25961:51;;26045:4;26041:9;26034:5;26030:21;26021:30;;26094:4;26084:8;26080:19;26073:5;26070:30;26060:40;;25789:317;;25713:393;;;;;:::o;26112:60::-;26140:3;26161:5;26154:12;;26112:60;;;:::o;26178:142::-;26228:9;26261:53;26279:34;26288:24;26306:5;26288:24;:::i;:::-;26279:34;:::i;:::-;26261:53;:::i;:::-;26248:66;;26178:142;;;:::o;26326:75::-;26369:3;26390:5;26383:12;;26326:75;;;:::o;26407:269::-;26517:39;26548:7;26517:39;:::i;:::-;26578:91;26627:41;26651:16;26627:41;:::i;:::-;26619:6;26612:4;26606:11;26578:91;:::i;:::-;26572:4;26565:105;26483:193;26407:269;;;:::o;26682:73::-;26727:3;26682:73;:::o;26761:189::-;26838:32;;:::i;:::-;26879:65;26937:6;26929;26923:4;26879:65;:::i;:::-;26814:136;26761:189;;:::o;26956:186::-;27016:120;27033:3;27026:5;27023:14;27016:120;;;27087:39;27124:1;27117:5;27087:39;:::i;:::-;27060:1;27053:5;27049:13;27040:22;;27016:120;;;26956:186;;:::o;27148:543::-;27249:2;27244:3;27241:11;27238:446;;;27283:38;27315:5;27283:38;:::i;:::-;27367:29;27385:10;27367:29;:::i;:::-;27357:8;27353:44;27550:2;27538:10;27535:18;27532:49;;;27571:8;27556:23;;27532:49;27594:80;27650:22;27668:3;27650:22;:::i;:::-;27640:8;27636:37;27623:11;27594:80;:::i;:::-;27253:431;;27238:446;27148:543;;;:::o;27697:117::-;27751:8;27801:5;27795:4;27791:16;27770:37;;27697:117;;;;:::o;27820:169::-;27864:6;27897:51;27945:1;27941:6;27933:5;27930:1;27926:13;27897:51;:::i;:::-;27893:56;27978:4;27972;27968:15;27958:25;;27871:118;27820:169;;;;:::o;27994:295::-;28070:4;28216:29;28241:3;28235:4;28216:29;:::i;:::-;28208:37;;28278:3;28275:1;28271:11;28265:4;28262:21;28254:29;;27994:295;;;;:::o;28294:1395::-;28411:37;28444:3;28411:37;:::i;:::-;28513:18;28505:6;28502:30;28499:56;;;28535:18;;:::i;:::-;28499:56;28579:38;28611:4;28605:11;28579:38;:::i;:::-;28664:67;28724:6;28716;28710:4;28664:67;:::i;:::-;28758:1;28782:4;28769:17;;28814:2;28806:6;28803:14;28831:1;28826:618;;;;29488:1;29505:6;29502:77;;;29554:9;29549:3;29545:19;29539:26;29530:35;;29502:77;29605:67;29665:6;29658:5;29605:67;:::i;:::-;29599:4;29592:81;29461:222;28796:887;;28826:618;28878:4;28874:9;28866:6;28862:22;28912:37;28944:4;28912:37;:::i;:::-;28971:1;28985:208;28999:7;28996:1;28993:14;28985:208;;;29078:9;29073:3;29069:19;29063:26;29055:6;29048:42;29129:1;29121:6;29117:14;29107:24;;29176:2;29165:9;29161:18;29148:31;;29022:4;29019:1;29015:12;29010:17;;28985:208;;;29221:6;29212:7;29209:19;29206:179;;;29279:9;29274:3;29270:19;29264:26;29322:48;29364:4;29356:6;29352:17;29341:9;29322:48;:::i;:::-;29314:6;29307:64;29229:156;29206:179;29431:1;29427;29419:6;29415:14;29411:22;29405:4;29398:36;28833:611;;;28796:887;;28386:1303;;;28294:1395;;:::o;29695:175::-;29835:27;29831:1;29823:6;29819:14;29812:51;29695:175;:::o;29876:366::-;30018:3;30039:67;30103:2;30098:3;30039:67;:::i;:::-;30032:74;;30115:93;30204:3;30115:93;:::i;:::-;30233:2;30228:3;30224:12;30217:19;;29876:366;;;:::o;30248:419::-;30414:4;30452:2;30441:9;30437:18;30429:26;;30501:9;30495:4;30491:20;30487:1;30476:9;30472:17;30465:47;30529:131;30655:4;30529:131;:::i;:::-;30521:139;;30248:419;;;:::o;30673:237::-;30813:34;30809:1;30801:6;30797:14;30790:58;30882:20;30877:2;30869:6;30865:15;30858:45;30673:237;:::o;30916:366::-;31058:3;31079:67;31143:2;31138:3;31079:67;:::i;:::-;31072:74;;31155:93;31244:3;31155:93;:::i;:::-;31273:2;31268:3;31264:12;31257:19;;30916:366;;;:::o;31288:419::-;31454:4;31492:2;31481:9;31477:18;31469:26;;31541:9;31535:4;31531:20;31527:1;31516:9;31512:17;31505:47;31569:131;31695:4;31569:131;:::i;:::-;31561:139;;31288:419;;;:::o;31713:148::-;31815:11;31852:3;31837:18;;31713:148;;;;:::o;31867:390::-;31973:3;32001:39;32034:5;32001:39;:::i;:::-;32056:89;32138:6;32133:3;32056:89;:::i;:::-;32049:96;;32154:65;32212:6;32207:3;32200:4;32193:5;32189:16;32154:65;:::i;:::-;32244:6;32239:3;32235:16;32228:23;;31977:280;31867:390;;;;:::o;32263:435::-;32443:3;32465:95;32556:3;32547:6;32465:95;:::i;:::-;32458:102;;32577:95;32668:3;32659:6;32577:95;:::i;:::-;32570:102;;32689:3;32682:10;;32263:435;;;;;:::o;32704:98::-;32755:6;32789:5;32783:12;32773:22;;32704:98;;;:::o;32808:168::-;32891:11;32925:6;32920:3;32913:19;32965:4;32960:3;32956:14;32941:29;;32808:168;;;;:::o;32982:373::-;33068:3;33096:38;33128:5;33096:38;:::i;:::-;33150:70;33213:6;33208:3;33150:70;:::i;:::-;33143:77;;33229:65;33287:6;33282:3;33275:4;33268:5;33264:16;33229:65;:::i;:::-;33319:29;33341:6;33319:29;:::i;:::-;33314:3;33310:39;33303:46;;33072:283;32982:373;;;;:::o;33361:640::-;33556:4;33594:3;33583:9;33579:19;33571:27;;33608:71;33676:1;33665:9;33661:17;33652:6;33608:71;:::i;:::-;33689:72;33757:2;33746:9;33742:18;33733:6;33689:72;:::i;:::-;33771;33839:2;33828:9;33824:18;33815:6;33771:72;:::i;:::-;33890:9;33884:4;33880:20;33875:2;33864:9;33860:18;33853:48;33918:76;33989:4;33980:6;33918:76;:::i;:::-;33910:84;;33361:640;;;;;;;:::o;34007:141::-;34063:5;34094:6;34088:13;34079:22;;34110:32;34136:5;34110:32;:::i;:::-;34007:141;;;;:::o;34154:349::-;34223:6;34272:2;34260:9;34251:7;34247:23;34243:32;34240:119;;;34278:79;;:::i;:::-;34240:119;34398:1;34423:63;34478:7;34469:6;34458:9;34454:22;34423:63;:::i;:::-;34413:73;;34369:127;34154:349;;;;:::o;34509:182::-;34649:34;34645:1;34637:6;34633:14;34626:58;34509:182;:::o;34697:366::-;34839:3;34860:67;34924:2;34919:3;34860:67;:::i;:::-;34853:74;;34936:93;35025:3;34936:93;:::i;:::-;35054:2;35049:3;35045:12;35038:19;;34697:366;;;:::o;35069:419::-;35235:4;35273:2;35262:9;35258:18;35250:26;;35322:9;35316:4;35312:20;35308:1;35297:9;35293:17;35286:47;35350:131;35476:4;35350:131;:::i;:::-;35342:139;;35069:419;;;:::o;35494:178::-;35634:30;35630:1;35622:6;35618:14;35611:54;35494:178;:::o;35678:366::-;35820:3;35841:67;35905:2;35900:3;35841:67;:::i;:::-;35834:74;;35917:93;36006:3;35917:93;:::i;:::-;36035:2;36030:3;36026:12;36019:19;;35678:366;;;:::o;36050:419::-;36216:4;36254:2;36243:9;36239:18;36231:26;;36303:9;36297:4;36293:20;36289:1;36278:9;36274:17;36267:47;36331:131;36457:4;36331:131;:::i;:::-;36323:139;;36050:419;;;:::o;36475:180::-;36523:77;36520:1;36513:88;36620:4;36617:1;36610:15;36644:4;36641:1;36634:15

Swarm Source

ipfs://fd031f0281d8cc874cc49016405384a19de1a04b22dc7023f49a9cd4deb7148b
Loading...
Loading
[ Download: CSV Export  ]
[ Download: CSV Export  ]

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.