Token

Regional Initiative (KNB)

ERC-1155

Overview

Max Total Supply

84 KNB

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xf78c9ec9878b07a227b8eb56bd6818e66f2f8f89

Filtered by Token Holder

0xB8d0454A82cd8b323763b2FA88502A38FB511B80

0xb8d0454a82cd8b323763b2fa88502a38fb511b80

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

KDDINFTPROJECT

Compiler Version

v0.8.18+commit.87f61d96

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-06-23
*/

// SPDX-License-Identifier: MIT
// File operator-filter-registry/src/[email protected]

library Base64 {
    string internal constant TABLE_ENCODE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
    bytes  internal constant TABLE_DECODE = hex"0000000000000000000000000000000000000000000000000000000000000000"
                                            hex"00000000000000000000003e0000003f3435363738393a3b3c3d000000000000"
                                            hex"00000102030405060708090a0b0c0d0e0f101112131415161718190000000000"
                                            hex"001a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132330000000000";

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

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

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

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

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

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

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

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

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

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

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

        return result;
    }

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

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

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

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

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

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

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

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

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

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

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

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

        return result;
    }
}

pragma solidity ^0.8.13;
interface IOperatorFilterRegistry {
    function isOperatorAllowed(address registrant, address operator) external view returns (bool);
    function register(address registrant) external;
    function registerAndSubscribe(address registrant, address subscription) external;
    function registerAndCopyEntries(address registrant, address registrantToCopy) external;
    function unregister(address addr) external;
    function updateOperator(address registrant, address operator, bool filtered) external;
    function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
    function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
    function subscribe(address registrant, address registrantToSubscribe) external;
    function unsubscribe(address registrant, bool copyExistingEntries) external;
    function subscriptionOf(address addr) external returns (address registrant);
    function subscribers(address registrant) external returns (address[] memory);
    function subscriberAt(address registrant, uint256 index) external returns (address);
    function copyEntriesOf(address registrant, address registrantToCopy) external;
    function isOperatorFiltered(address registrant, address operator) external returns (bool);
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
    function filteredOperators(address addr) external returns (address[] memory);
    function filteredCodeHashes(address addr) external returns (bytes32[] memory);
    function filteredOperatorAt(address registrant, uint256 index) external returns (address);
    function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
    function isRegistered(address addr) external returns (bool);
    function codeHashOf(address addr) external returns (bytes32);
}


// File operator-filter-registry/src/[email protected]

pragma solidity ^0.8.13;

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

    bool public operatorFilteringEnabled = true;

    IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY =
        IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);

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

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

    modifier onlyAllowedOperatorApproval(address operator) virtual {
        _checkFilterOperator(operator);
        _;
    }

    function _checkFilterOperator(address operator) internal view virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0 && operatorFilteringEnabled) {
            if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
                revert OperatorNotAllowed(operator);
            }
        }
    }
}


// File operator-filter-registry/src/[email protected]

pragma solidity ^0.8.13;

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

    constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}


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

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

pragma solidity ^0.8.0;

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

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

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

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

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


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

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

pragma solidity ^0.8.0;

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

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


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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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


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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

pragma solidity ^0.8.0;

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

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

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

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

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


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

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

pragma solidity ^0.8.0;

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


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

// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        returns (address receiver, uint256 royaltyAmount);
}


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

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

pragma solidity ^0.8.0;

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


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

// OpenZeppelin Contracts (last updated v4.7.0) (token/common/ERC2981.sol)

pragma solidity ^0.8.0;


/**
 * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
 *
 * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
 * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
 *
 * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
 * fee is specified in basis points by default.
 *
 * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
 * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
 * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
 *
 * _Available since v4.5._
 */
abstract contract ERC2981 is IERC2981, ERC165 {
    struct RoyaltyInfo {
        address receiver;
        uint96 royaltyFraction;
    }

    RoyaltyInfo private _defaultRoyaltyInfo;
    mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;

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

    /**
     * @inheritdoc IERC2981
     */
    function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256) {
        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];

        if (royalty.receiver == address(0)) {
            royalty = _defaultRoyaltyInfo;
        }

        uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator();

        return (royalty.receiver, royaltyAmount);
    }

    /**
     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
     * override.
     */
    function _feeDenominator() internal pure virtual returns (uint96) {
        return 10000;
    }

    /**
     * @dev Sets the royalty information that all ids in this contract will default to.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: invalid receiver");

        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Removes default royalty information.
     */
    function _deleteDefaultRoyalty() internal virtual {
        delete _defaultRoyaltyInfo;
    }

    /**
     * @dev Sets the royalty information for a specific token id, overriding the global default.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setTokenRoyalty(
        uint256 tokenId,
        address receiver,
        uint96 feeNumerator
    ) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: Invalid parameters");

        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Resets royalty information for the token id back to the global default.
     */
    function _resetTokenRoyalty(uint256 tokenId) internal virtual {
        delete _tokenRoyaltyInfo[tokenId];
    }
}


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

// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.0;

/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external
        view
        returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}


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

// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}


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

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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


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

// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the optional ERC1155MetadataExtension interface, as defined
 * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155MetadataURI is IERC1155 {
    /**
     * @dev Returns the URI for token type `id`.
     *
     * If the `\{id\}` substring is present in the URI, it must be replaced by
     * clients with the actual token type ID.
     */
    function uri(uint256 id) external view returns (string memory);
}


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

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

pragma solidity ^0.8.0;






/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 *
 * _Available since v3.1._
 */
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
    using Address for address;

    // Mapping from token ID to account balances
    mapping(uint256 => mapping(address => uint256)) private _balances;

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

    // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
    string private _uri;

    /**
     * @dev See {_setURI}.
     */
    constructor(string memory uri_) {
        _setURI(uri_);
    }

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

    /**
     * @dev See {IERC1155MetadataURI-uri}.
     *
     * This implementation returns the same URI for *all* token types. It relies
     * on the token type ID substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * Clients calling this function must replace the `\{id\}` substring with the
     * actual token type ID.
     */
    function uri(uint256) public view virtual override returns (string memory) {
        return _uri;
    }

    /**
     * @dev See {IERC1155-balanceOf}.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
        require(account != address(0), "ERC1155: address zero is not a valid owner");
        return _balances[id][account];
    }

    /**
     * @dev See {IERC1155-balanceOfBatch}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
        public
        view
        virtual
        override
        returns (uint256[] memory)
    {
        require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");

        uint256[] memory batchBalances = new uint256[](accounts.length);

        for (uint256 i = 0; i < accounts.length; ++i) {
            batchBalances[i] = balanceOf(accounts[i], ids[i]);
        }

        return batchBalances;
    }

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

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

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not token owner or approved"
        );
        _safeTransferFrom(from, to, id, amount, data);
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not token owner or approved"
        );
        _safeBatchTransferFrom(from, to, ids, amounts, data);
    }

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: transfer to the zero address");

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

        _beforeTokenTransfer(operator, from, to, ids, amounts, data);

        uint256 fromBalance = _balances[id][from];
        require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
        unchecked {
            _balances[id][from] = fromBalance - amount;
        }
        _balances[id][to] += amount;

        emit TransferSingle(operator, from, to, id, amount);

        _afterTokenTransfer(operator, from, to, ids, amounts, data);

        _doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
        require(to != address(0), "ERC1155: transfer to the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, ids, amounts, data);

        for (uint256 i = 0; i < ids.length; ++i) {
            uint256 id = ids[i];
            uint256 amount = amounts[i];

            uint256 fromBalance = _balances[id][from];
            require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
            unchecked {
                _balances[id][from] = fromBalance - amount;
            }
            _balances[id][to] += amount;
        }

        emit TransferBatch(operator, from, to, ids, amounts);

        _afterTokenTransfer(operator, from, to, ids, amounts, data);

        _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
    }

    /**
     * @dev Sets a new URI for all token types, by relying on the token type ID
     * substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * By this mechanism, any occurrence of the `\{id\}` substring in either the
     * URI or any of the amounts in the JSON file at said URI will be replaced by
     * clients with the token type ID.
     *
     * For example, the `https://token-cdn-domain/\{id\}.json` URI would be
     * interpreted by clients as
     * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
     * for token type ID 0x4cce0.
     *
     * See {uri}.
     *
     * Because these URIs cannot be meaningfully represented by the {URI} event,
     * this function emits no events.
     */
    function _setURI(string memory newuri) internal virtual {
        _uri = newuri;
    }

    /**
     * @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

        _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);

        _balances[id][to] += amount;
        emit TransferSingle(operator, address(0), to, id, amount);

        _afterTokenTransfer(operator, address(0), to, ids, amounts, data);

        _doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);

        for (uint256 i = 0; i < ids.length; i++) {
            _balances[ids[i]][to] += amounts[i];
        }

        emit TransferBatch(operator, address(0), to, ids, amounts);

        _afterTokenTransfer(operator, address(0), to, ids, amounts, data);

        _doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
    }

    /**
     * @dev Destroys `amount` tokens of token type `id` from `from`
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have at least `amount` tokens of token type `id`.
     */
    function _burn(
        address from,
        uint256 id,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC1155: burn from the zero address");

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

        _beforeTokenTransfer(operator, from, address(0), ids, amounts, "");

        uint256 fromBalance = _balances[id][from];
        require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
        unchecked {
            _balances[id][from] = fromBalance - amount;
        }

        emit TransferSingle(operator, from, address(0), id, amount);

        _afterTokenTransfer(operator, from, address(0), ids, amounts, "");
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     */
    function _burnBatch(
        address from,
        uint256[] memory ids,
        uint256[] memory amounts
    ) internal virtual {
        require(from != address(0), "ERC1155: burn from the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, address(0), ids, amounts, "");

        for (uint256 i = 0; i < ids.length; i++) {
            uint256 id = ids[i];
            uint256 amount = amounts[i];

            uint256 fromBalance = _balances[id][from];
            require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
            unchecked {
                _balances[id][from] = fromBalance - amount;
            }
        }

        emit TransferBatch(operator, from, address(0), ids, amounts);

        _afterTokenTransfer(operator, from, address(0), ids, amounts, "");
    }

    /**
     * @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, "ERC1155: setting approval status for self");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning, as well as batched variants.
     *
     * The same hook is called on both single and batched variants. For single
     * transfers, the length of the `ids` and `amounts` arrays will be 1.
     *
     * Calling conditions (for each `id` and `amount` pair):
     *
     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * of token type `id` will be  transferred to `to`.
     * - When `from` is zero, `amount` tokens of token type `id` will be minted
     * for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
     * will be burned.
     * - `from` and `to` are never both zero.
     * - `ids` and `amounts` have the same, non-zero length.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}

    /**
     * @dev Hook that is called after any token transfer. This includes minting
     * and burning, as well as batched variants.
     *
     * The same hook is called on both single and batched variants. For single
     * transfers, the length of the `id` and `amount` arrays will be 1.
     *
     * Calling conditions (for each `id` and `amount` pair):
     *
     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * of token type `id` will be  transferred to `to`.
     * - When `from` is zero, `amount` tokens of token type `id` will be minted
     * for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
     * will be burned.
     * - `from` and `to` are never both zero.
     * - `ids` and `amounts` have the same, non-zero length.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}

    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
                if (response != IERC1155Receiver.onERC1155Received.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non-ERC1155Receiver implementer");
            }
        }
    }

    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
                bytes4 response
            ) {
                if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non-ERC1155Receiver implementer");
            }
        }
    }

    function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
        uint256[] memory array = new uint256[](1);
        array[0] = element;

        return array;
    }
}


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

// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC1155/extensions/ERC1155Burnable.sol)

pragma solidity ^0.8.0;

/**
 * @dev Extension of {ERC1155} that allows token holders to destroy both their
 * own tokens and those that they have been approved to use.
 *
 * _Available since v3.1._
 */
abstract contract ERC1155Burnable is ERC1155 {
    function burn(
        address account,
        uint256 id,
        uint256 value
    ) public virtual {
        require(
            account == _msgSender() || isApprovedForAll(account, _msgSender()),
            "ERC1155: caller is not token owner or approved"
        );

        _burn(account, id, value);
    }

    function burnBatch(
        address account,
        uint256[] memory ids,
        uint256[] memory values
    ) public virtual {
        require(
            account == _msgSender() || isApprovedForAll(account, _msgSender()),
            "ERC1155: caller is not token owner or approved"
        );

        _burnBatch(account, ids, values);
    }
}

//merkle
pragma solidity ^0.8.0;

library MerkleProof {

    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    function verifyCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;

        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

pragma solidity ^0.8.0;

abstract contract ReentrancyGuard {
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        _status = _NOT_ENTERED;
    }
}


pragma solidity ^0.8.17;

contract KDDINFTPROJECT is ERC1155, ERC2981, Ownable, ReentrancyGuard, DefaultOperatorFilterer {
    string public name = "Regional Initiative";
    string public symbol = "KNB";
    uint256 public maxSupply = 300;
    uint256 public totalSupply;
    mapping(uint256 => uint256) public numberTotalSupply;
    mapping(uint256 => uint256) public numberLimit;
    uint256 public prePrice = 0.03 ether;
    uint256 public publicPrice;
    bool public preSaleStart = true;
    bool public publicSaleStart = false;
    bytes32 public merkleRoot = 0xf5f9e9e44a5a6b154816fe97fe3a0f6420788c9ff5bcee39b72b2a5945bbe59d;
    uint256 public mintLimit = 2;
    mapping(address => uint256) public minted;
    mapping(uint256 => string) private _tokenURI;
    uint256 public tokenKinds = 2;

    using Counters for Counters.Counter;
    Counters.Counter private _tokenIdTracker;

    uint256 private constant TOKEN_TYPES = 3;
    uint256 private constant PROBABILITY = 10000; // 1/10000 chance for each token

    constructor() ERC1155("") {
        _setDefaultRoyalty(0x0Fe2Ed60e1408E6868B01111681e6C72D10768Ff, 1000);
        setURI(0, "https://arweave.net/Ve0KWRPdT1k5j-c5w_OI4zuk5glUesBOtwzqggsdyZU/0.json");
        setURI(1, "https://arweave.net/Ve0KWRPdT1k5j-c5w_OI4zuk5glUesBOtwzqggsdyZU/1.json");
        setURI(2, "https://arweave.net/Ve0KWRPdT1k5j-c5w_OI4zuk5glUesBOtwzqggsdyZU/2.json");
        setNumberLimit(0, 100);
        setNumberLimit(1, 100);
        setNumberLimit(2, 100);
    }

    // tokenUri
    function uri(uint256 _tokenId) public view override returns (string memory) {
        return _tokenURI[_tokenId];
    }

    function setURI(uint256 _tokenId, string memory _uri) public onlyOwner {
        _tokenURI[_tokenId] = _uri;
    }

    // saleStart
    function setPreSaleStart(bool _preState) public onlyOwner {
        preSaleStart = _preState;
    }

    function setPublicSaleStart(bool _publicState) public onlyOwner {
        publicSaleStart = _publicState;
    }

    // merkle
    function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
        merkleRoot = _merkleRoot;
    }

    function checkMerkleProof(bytes32[] calldata _merkleProof) public view returns (bool) {
        bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
        return MerkleProof.verifyCalldata(_merkleProof, merkleRoot, leaf);
    }

    // price
    function setPrePrice(uint256 _newPrePrice) public onlyOwner {
        prePrice = _newPrePrice;
    }

    function setPublicPrice(uint256 _newPublicPrice) public onlyOwner {
        publicPrice = _newPublicPrice;
    }

    // limit
    function setMintLimit(uint256 _newLimit) public onlyOwner {
        mintLimit = _newLimit;
    }

    // maxSupply
    function setMaxSupply(uint256 _maxSupply) public onlyOwner {
        require(totalSupply <= _maxSupply, "under totalSupply");
        maxSupply = _maxSupply;
    }

    function setNumberLimit(uint256 _tokenId, uint256 _limit) public onlyOwner {
        require(numberTotalSupply[_tokenId] <= _limit, "under totalSupply");
        numberLimit[_tokenId] = _limit;
    }

    function _generateRandomTokenType(uint256 salt) private view returns (uint256) {
        uint256 randomNumber = uint256(keccak256(abi.encodePacked(block.timestamp, block.prevrandao, _tokenIdTracker.current(), salt)));
        uint256 randomIndex = randomNumber % PROBABILITY;
        uint256 currentTokenType = randomIndex % TOKEN_TYPES;

        if (numberTotalSupply[0] < numberLimit[0] && numberTotalSupply[1] < numberLimit[1] && numberTotalSupply[2] < numberLimit[2]) {
            return currentTokenType;
        }

        if(currentTokenType == 0){
            if (numberTotalSupply[0] < numberLimit[0]) {
                return 0;
            }
            if (numberTotalSupply[1] < numberLimit[1]) {
                return 1;
            }
            if (numberTotalSupply[2] < numberLimit[2]) {
                return 2;
            }
        }
        if(currentTokenType == 1){
            if (numberTotalSupply[1] < numberLimit[1]) {
                return 1;
            }
            if (numberTotalSupply[0] < numberLimit[0]) {
                return 0;
            }
            if (numberTotalSupply[2] < numberLimit[2]) {
                return 2;
            }
        }

        if(currentTokenType == 2){
            if (numberTotalSupply[2] < numberLimit[2]) {
                return 2;
            }
            if (numberTotalSupply[0] < numberLimit[0]) {
                return 0;
            }
            if (numberTotalSupply[1] < numberLimit[1]) {
                return 1;
            }
        }

        return currentTokenType;
    }

    // mint
    function preMint(uint256 _amount, bytes32[] calldata _merkleProof) public payable nonReentrant {
        require(checkMerkleProof(_merkleProof), "Invalid Merkle Proof");
        require(preSaleStart, "before saleStart");
        require(mintLimit >= minted[msg.sender] + _amount, "mintLimit over");
        require(maxSupply >= totalSupply + _amount, "maxSupply over");
        require(msg.value >= prePrice * _amount, "Value sent is not correct");

        for (uint256 i = 0; i < _amount; i++) {
            uint256 tokenType = _generateRandomTokenType(i);

            _mint(msg.sender, tokenType, 1, "");
            totalSupply += 1;
            numberTotalSupply[tokenType] += 1;
            minted[msg.sender] += 1;
        }
    }

    function publicMint(uint256 _amount) public payable {
        require(publicSaleStart, "before saleStart");
        require(mintLimit >= minted[msg.sender] + _amount, "mintLimit over");
        require(maxSupply >= totalSupply + _amount, "maxSupply over");
        require(msg.value >= publicPrice * _amount, "Value sent is not correct");

        for (uint256 i = 0; i < _amount; i++) {
            uint256 tokenType = _generateRandomTokenType(i);

            _mint(msg.sender, tokenType, 1, "");
            totalSupply += 1;
            numberTotalSupply[tokenType] += 1;
            minted[msg.sender] += 1;
        }
    }


    function ownerMint(address to, uint256 _tokenId, uint256 _amount) public onlyOwner {
        require(maxSupply >= totalSupply + _amount, "maxSupply over");
        require(tokenKinds >= _tokenId, "Token not issued");
        require(numberLimit[_tokenId] >= numberTotalSupply[_tokenId] + _amount, "Limit over");

        _mint(to, _tokenId, _amount, "");
        totalSupply += _amount;
        numberTotalSupply[_tokenId] += _amount;
    }

    // withdraw
    function withdraw() external onlyOwner {
        uint256 sendAmount = address(this).balance;
        address founder = payable(0x0Fe2Ed60e1408E6868B01111681e6C72D10768Ff);
        bool success;
        (success, ) = founder.call{value: (sendAmount * 1000/1000)}("");
        require(success, "Failed to withdraw Ether");
    }

    // OpenSea OperatorFilterer
    function setOperatorFilteringEnabled(bool _state) external onlyOwner {
        operatorFilteringEnabled = _state;
    }

    function setApprovalForAll(address operator, bool approved)
        public
        override
        onlyAllowedOperatorApproval(operator)
    {
        super.setApprovalForAll(operator, approved);
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        uint256 amount,
        bytes memory data
    ) public override onlyAllowedOperator(from) {
        super.safeTransferFrom(from, to, tokenId, amount, data);
    }

    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public virtual override onlyAllowedOperator(from) {
        super.safeBatchTransferFrom(from, to, ids, amounts, data);
    }

    // Royality
    function setRoyalty(address _royaltyAddress, uint96 _feeNumerator)
        external
        onlyOwner
    {
        _setDefaultRoyalty(_royaltyAddress, _feeNumerator);
    }

    function supportsInterface(bytes4 _interfaceId)
        public
        view
        virtual
        override(ERC1155, ERC2981)
        returns (bool)
    {
        return
            ERC1155.supportsInterface(_interfaceId) ||
            ERC2981.supportsInterface(_interfaceId);
    }

    //for ERC2981 Opensea
    function contractURI() external view virtual returns (string memory) {
            return _formatContractURI();
    }
    //make contractURI
    function _formatContractURI() internal view returns (string memory) {
        (address receiver, uint256 royaltyFraction) = royaltyInfo(0,_feeDenominator());//tokenid=0
        return string(
        abi.encodePacked(
            "data:application/json;base64,",
            Base64.encode(
            bytes(
                abi.encodePacked(
                    '{"seller_fee_basis_points":', Strings.toString(royaltyFraction),
                    ', "fee_recipient":"', Strings.toHexString(uint256(uint160(receiver)), 20), '"}'
                )
            )
            )
        )
        );
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[],"name":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"}],"name":"checkMerkleProof","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"minted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"numberLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"numberTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operatorFilteringEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"ownerMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"}],"name":"preMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"prePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"preSaleStart","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"publicMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"publicPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicSaleStart","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","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":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxSupply","type":"uint256"}],"name":"setMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newLimit","type":"uint256"}],"name":"setMintLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_limit","type":"uint256"}],"name":"setNumberLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setOperatorFilteringEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newPrePrice","type":"uint256"}],"name":"setPrePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_preState","type":"bool"}],"name":"setPreSaleStart","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newPublicPrice","type":"uint256"}],"name":"setPublicPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_publicState","type":"bool"}],"name":"setPublicSaleStart","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_royaltyAddress","type":"address"},{"internalType":"uint96","name":"_feeNumerator","type":"uint96"}],"name":"setRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"string","name":"_uri","type":"string"}],"name":"setURI","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":[],"name":"tokenKinds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

78216:9312:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56592:230;;;;;;;;;;-1:-1:-1;56592:230:0;;;;;:::i;:::-;;:::i;:::-;;;597:25:1;;;585:2;570:18;56592:230:0;;;;;;;;86430:294;;;;;;;;;;-1:-1:-1;86430:294:0;;;;;:::i;:::-;;:::i;:::-;;;1184:14:1;;1177:22;1159:41;;1147:2;1132:18;86430:294:0;1019:187:1;78318:42:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;78660:31::-;;;;;;;;;;-1:-1:-1;78660:31:0;;;;;;;;79756:121;;;;;;;;;;-1:-1:-1;79756:121:0;;;;;:::i;:::-;;:::i;78439:26::-;;;;;;;;;;;;;;;;78876:41;;;;;;;;;;-1:-1:-1;78876:41:0;;;;;:::i;:::-;;;;;;;;;;;;;;35113:442;;;;;;;;;;-1:-1:-1;35113:442:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;2788:32:1;;;2770:51;;2852:2;2837:18;;2830:34;;;;2743:18;35113:442:0;2596:274:1;83794:642:0;;;;;;:::i;:::-;;:::i;:::-;;85917:302;;;;;;;;;;-1:-1:-1;85917:302:0;;;;;:::i;:::-;;:::i;78740:94::-;;;;;;;;;;;;;;;;78698:35;;;;;;;;;;-1:-1:-1;78698:35:0;;;;;;;;;;;84446:448;;;;;;;;;;-1:-1:-1;84446:448:0;;;;;:::i;:::-;;:::i;84919:332::-;;;;;;;;;;;;;:::i;80136:113::-;;;;;;;;;;-1:-1:-1;80136:113:0;;;;;:::i;:::-;;:::i;7782:143::-;;;;;;;;;;;;7882:42;7782:143;;;;;-1:-1:-1;;;;;6897:32:1;;;6879:51;;6867:2;6852:18;7782:143:0;6702:234:1;56988:524:0;;;;;;;;;;-1:-1:-1;56988:524:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;83033:753::-;;;;;;:::i;:::-;;:::i;81013:166::-;;;;;;;;;;-1:-1:-1;81013:166:0;;;;;:::i;:::-;;:::i;14569:103::-;;;;;;;;;;;;;:::i;78975:29::-;;;;;;;;;;;;;;;;80272:106;;;;;;;;;;-1:-1:-1;80272:106:0;;;;;:::i;:::-;;:::i;78472:52::-;;;;;;;;;;-1:-1:-1;78472:52:0;;;;;:::i;:::-;;;;;;;;;;;;;;79885:116;;;;;;;;;;-1:-1:-1;79885:116:0;;;;;:::i;:::-;;:::i;81187:202::-;;;;;;;;;;-1:-1:-1;81187:202:0;;;;;:::i;:::-;;:::i;13921:87::-;;;;;;;;;;-1:-1:-1;13994:6:0;;-1:-1:-1;;;;;13994:6:0;13921:87;;86244:178;;;;;;;;;;-1:-1:-1;86244:178:0;;;;;:::i;:::-;;:::i;78367:28::-;;;;;;;;;;;;;:::i;78841:::-;;;;;;;;;;;;;;;;80889:98;;;;;;;;;;-1:-1:-1;80889:98:0;;;;;:::i;:::-;;:::i;85421:208::-;;;;;;;;;;-1:-1:-1;85421:208:0;;;;;:::i;:::-;;:::i;80027:101::-;;;;;;;;;;-1:-1:-1;80027:101:0;;;;;:::i;:::-;;:::i;78627:26::-;;;;;;;;;;;;;;;;80386:235;;;;;;;;;;-1:-1:-1;80386:235:0;;;;;:::i;:::-;;:::i;85292:121::-;;;;;;;;;;-1:-1:-1;85292:121:0;;;;;:::i;:::-;;:::i;78531:46::-;;;;;;;;;;-1:-1:-1;78531:46:0;;;;;:::i;:::-;;;;;;;;;;;;;;80753:114;;;;;;;;;;-1:-1:-1;80753:114:0;;;;;:::i;:::-;;:::i;80643:102::-;;;;;;;;;;-1:-1:-1;80643:102:0;;;;;:::i;:::-;;:::i;78402:30::-;;;;;;;;;;;;;;;;78584:36;;;;;;;;;;;;;;;;86759:119;;;;;;;;;;;;;:::i;57812:168::-;;;;;;;;;;-1:-1:-1;57812:168:0;;;;;:::i;:::-;-1:-1:-1;;;;;57935:27:0;;;57911:4;57935:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;57812:168;85637:272;;;;;;;;;;-1:-1:-1;85637:272:0;;;;;:::i;:::-;;:::i;14827:201::-;;;;;;;;;;-1:-1:-1;14827:201:0;;;;;:::i;:::-;;:::i;7730:43::-;;;;;;;;;;-1:-1:-1;7730:43:0;;;;;;;;56592:230;56678:7;-1:-1:-1;;;;;56706:21:0;;56698:76;;;;-1:-1:-1;;;56698:76:0;;12869:2:1;56698:76:0;;;12851:21:1;12908:2;12888:18;;;12881:30;12947:34;12927:18;;;12920:62;-1:-1:-1;;;12998:18:1;;;12991:40;13048:19;;56698:76:0;;;;;;;;;-1:-1:-1;56792:9:0;:13;;;;;;;;;;;-1:-1:-1;;;;;56792:22:0;;;;;;;;;;56592:230;;;;;:::o;86430:294::-;86579:4;86621:39;86647:12;86621:25;:39::i;:::-;:95;;;;86677:39;86703:12;86677:25;:39::i;78318:42::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;79756:121::-;79850:19;;;;:9;:19;;;;;79843:26;;79817:13;;79850:19;79843:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79756:121;;;:::o;35113:442::-;35210:7;35268:27;;;:17;:27;;;;;;;;35239:56;;;;;;;;;-1:-1:-1;;;;;35239:56:0;;;;;-1:-1:-1;;;35239:56:0;;;-1:-1:-1;;;;;35239:56:0;;;;;;;;35210:7;;35308:92;;-1:-1:-1;35359:29:0;;;;;;;;;35369:19;35359:29;-1:-1:-1;;;;;35359:29:0;;;;-1:-1:-1;;;35359:29:0;;-1:-1:-1;;;;;35359:29:0;;;;;35308:92;35450:23;;;;35412:21;;35921:5;;35437:36;;-1:-1:-1;;;;;35437:36:0;:10;:36;:::i;:::-;35436:58;;;;:::i;:::-;35515:16;;;-1:-1:-1;35412:82:0;;-1:-1:-1;;35113:442:0;;;;;;:::o;83794:642::-;83865:15;;;;;;;83857:44;;;;-1:-1:-1;;;83857:44:0;;14227:2:1;83857:44:0;;;14209:21:1;14266:2;14246:18;;;14239:30;-1:-1:-1;;;14285:18:1;;;14278:46;14341:18;;83857:44:0;14025:340:1;83857:44:0;83940:10;83933:18;;;;:6;:18;;;;;;:28;;83954:7;;83933:28;:::i;:::-;83920:9;;:41;;83912:68;;;;-1:-1:-1;;;83912:68:0;;14702:2:1;83912:68:0;;;14684:21:1;14741:2;14721:18;;;14714:30;-1:-1:-1;;;14760:18:1;;;14753:44;14814:18;;83912:68:0;14500:338:1;83912:68:0;84026:7;84012:11;;:21;;;;:::i;:::-;83999:9;;:34;;83991:61;;;;-1:-1:-1;;;83991:61:0;;;;;;;:::i;:::-;84098:7;84084:11;;:21;;;;:::i;:::-;84071:9;:34;;84063:72;;;;-1:-1:-1;;;84063:72:0;;15388:2:1;84063:72:0;;;15370:21:1;15427:2;15407:18;;;15400:30;-1:-1:-1;;;15446:18:1;;;15439:55;15511:18;;84063:72:0;15186:349:1;84063:72:0;84153:9;84148:281;84172:7;84168:1;:11;84148:281;;;84201:17;84221:27;84246:1;84221:24;:27::i;:::-;84201:47;;84265:35;84271:10;84283:9;84294:1;84265:35;;;;;;;;;;;;:5;:35::i;:::-;84330:1;84315:11;;:16;;;;;;;:::i;:::-;;;;-1:-1:-1;;84346:28:0;;;;:17;:28;;;;;:33;;84378:1;;84346:28;:33;;84378:1;;84346:33;:::i;:::-;;;;-1:-1:-1;;84401:10:0;84394:18;;;;:6;:18;;;;;:23;;84416:1;;84394:18;:23;;84416:1;;84394:23;:::i;:::-;;;;-1:-1:-1;84181:3:0;;-1:-1:-1;84181:3:0;;-1:-1:-1;84181:3:0;;:::i;:::-;;;;84148:281;;;;83794:642;:::o;85917:302::-;86137:4;-1:-1:-1;;;;;9123:18:0;;9131:10;9123:18;9119:83;;9158:32;9179:10;9158:20;:32::i;:::-;86154:57:::1;86182:4;86188:2;86192:3;86197:7;86206:4;86154:27;:57::i;:::-;85917:302:::0;;;;;;:::o;84446:448::-;13807:13;:11;:13::i;:::-;84575:7:::1;84561:11;;:21;;;;:::i;:::-;84548:9;;:34;;84540:61;;;;-1:-1:-1::0;;;84540:61:0::1;;;;;;;:::i;:::-;84634:8;84620:10;;:22;;84612:51;;;::::0;-1:-1:-1;;;84612:51:0;;15882:2:1;84612:51:0::1;::::0;::::1;15864:21:1::0;15921:2;15901:18;;;15894:30;-1:-1:-1;;;15940:18:1;;;15933:46;15996:18;;84612:51:0::1;15680:340:1::0;84612:51:0::1;84707:27;::::0;;;:17:::1;:27;::::0;;;;;:37:::1;::::0;84737:7;;84707:37:::1;:::i;:::-;84682:21;::::0;;;:11:::1;:21;::::0;;;;;:62:::1;;84674:85;;;::::0;-1:-1:-1;;;84674:85:0;;16227:2:1;84674:85:0::1;::::0;::::1;16209:21:1::0;16266:2;16246:18;;;16239:30;-1:-1:-1;;;16285:18:1;;;16278:40;16335:18;;84674:85:0::1;16025:334:1::0;84674:85:0::1;84772:32;84778:2;84782:8;84792:7;84772:32;;;;;;;;;;;::::0;:5:::1;:32::i;:::-;84830:7;84815:11;;:22;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;84848:27:0::1;::::0;;;:17:::1;:27;::::0;;;;:38;;84879:7;;84848:27;:38:::1;::::0;84879:7;;84848:38:::1;:::i;:::-;::::0;;;-1:-1:-1;;;;;84446:448:0:o;84919:332::-;13807:13;:11;:13::i;:::-;84990:21:::1;85048:42;84969:18;85048:42:::0;85178:4:::1;85160:17;84990:21:::0;85178:4;85160:17:::1;:::i;:::-;:22;;;;:::i;:::-;85139:49;::::0;::::1;::::0;;;;;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85125:63;;;;;85207:7;85199:44;;;::::0;-1:-1:-1;;;85199:44:0;;16776:2:1;85199:44:0::1;::::0;::::1;16758:21:1::0;16815:2;16795:18;;;16788:30;16854:26;16834:18;;;16827:54;16898:18;;85199:44:0::1;16574:348:1::0;85199:44:0::1;84958:293;;;84919:332::o:0;80136:113::-;13807:13;:11;:13::i;:::-;80211:15:::1;:30:::0;;;::::1;;;;-1:-1:-1::0;;80211:30:0;;::::1;::::0;;;::::1;::::0;;80136:113::o;56988:524::-;57144:16;57205:3;:10;57186:8;:15;:29;57178:83;;;;-1:-1:-1;;;57178:83:0;;17129:2:1;57178:83:0;;;17111:21:1;17168:2;17148:18;;;17141:30;17207:34;17187:18;;;17180:62;-1:-1:-1;;;17258:18:1;;;17251:39;17307:19;;57178:83:0;16927:405:1;57178:83:0;57274:30;57321:8;:15;-1:-1:-1;;;;;57307:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57307:30:0;;57274:63;;57355:9;57350:122;57374:8;:15;57370:1;:19;57350:122;;;57430:30;57440:8;57449:1;57440:11;;;;;;;;:::i;:::-;;;;;;;57453:3;57457:1;57453:6;;;;;;;;:::i;:::-;;;;;;;57430:9;:30::i;:::-;57411:13;57425:1;57411:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;57391:3;;;:::i;:::-;;;57350:122;;;-1:-1:-1;57491:13:0;56988:524;-1:-1:-1;;;56988:524:0:o;83033:753::-;77862:21;:19;:21::i;:::-;83147:30:::1;83164:12;;83147:16;:30::i;:::-;83139:63;;;::::0;-1:-1:-1;;;83139:63:0;;17671:2:1;83139:63:0::1;::::0;::::1;17653:21:1::0;17710:2;17690:18;;;17683:30;-1:-1:-1;;;17729:18:1;;;17722:50;17789:18;;83139:63:0::1;17469:344:1::0;83139:63:0::1;83221:12;::::0;::::1;;83213:41;;;::::0;-1:-1:-1;;;83213:41:0;;14227:2:1;83213:41:0::1;::::0;::::1;14209:21:1::0;14266:2;14246:18;;;14239:30;-1:-1:-1;;;14285:18:1;;;14278:46;14341:18;;83213:41:0::1;14025:340:1::0;83213:41:0::1;83293:10;83286:18;::::0;;;:6:::1;:18;::::0;;;;;:28:::1;::::0;83307:7;;83286:28:::1;:::i;:::-;83273:9;;:41;;83265:68;;;::::0;-1:-1:-1;;;83265:68:0;;14702:2:1;83265:68:0::1;::::0;::::1;14684:21:1::0;14741:2;14721:18;;;14714:30;-1:-1:-1;;;14760:18:1;;;14753:44;14814:18;;83265:68:0::1;14500:338:1::0;83265:68:0::1;83379:7;83365:11;;:21;;;;:::i;:::-;83352:9;;:34;;83344:61;;;;-1:-1:-1::0;;;83344:61:0::1;;;;;;;:::i;:::-;83448:7;83437:8;;:18;;;;:::i;:::-;83424:9;:31;;83416:69;;;::::0;-1:-1:-1;;;83416:69:0;;15388:2:1;83416:69:0::1;::::0;::::1;15370:21:1::0;15427:2;15407:18;;;15400:30;-1:-1:-1;;;15446:18:1;;;15439:55;15511:18;;83416:69:0::1;15186:349:1::0;83416:69:0::1;83503:9;83498:281;83522:7;83518:1;:11;83498:281;;;83551:17;83571:27;83596:1;83571:24;:27::i;:::-;83551:47;;83615:35;83621:10;83633:9;83644:1;83615:35;;;;;;;;;;;::::0;:5:::1;:35::i;:::-;83680:1;83665:11;;:16;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;83696:28:0::1;::::0;;;:17:::1;:28;::::0;;;;:33;;83728:1:::1;::::0;83696:28;:33:::1;::::0;83728:1;;83696:33:::1;:::i;:::-;::::0;;;-1:-1:-1;;83751:10:0::1;83744:18;::::0;;;:6:::1;:18;::::0;;;;:23;;83766:1:::1;::::0;83744:18;:23:::1;::::0;83766:1;;83744:23:::1;:::i;:::-;::::0;;;-1:-1:-1;83531:3:0;;-1:-1:-1;83531:3:0::1;::::0;-1:-1:-1;83531:3:0;::::1;:::i;:::-;;;;83498:281;;;;77906:20:::0;77678:1;78149:7;:22;78100:79;81013:166;13807:13;:11;:13::i;:::-;81106:10:::1;81091:11;;:25;;81083:55;;;::::0;-1:-1:-1;;;81083:55:0;;18020:2:1;81083:55:0::1;::::0;::::1;18002:21:1::0;18059:2;18039:18;;;18032:30;-1:-1:-1;;;18078:18:1;;;18071:47;18135:18;;81083:55:0::1;17818:341:1::0;81083:55:0::1;81149:9;:22:::0;81013:166::o;14569:103::-;13807:13;:11;:13::i;:::-;14634:30:::1;14661:1;14634:18;:30::i;:::-;14569:103::o:0;80272:106::-;13807:13;:11;:13::i;:::-;80346:10:::1;:24:::0;80272:106::o;79885:116::-;13807:13;:11;:13::i;:::-;79967:19:::1;::::0;;;:9:::1;:19;::::0;;;;:26:::1;79989:4:::0;79967:19;:26:::1;:::i;81187:202::-:0;13807:13;:11;:13::i;:::-;81281:27:::1;::::0;;;:17:::1;:27;::::0;;;;;:37;-1:-1:-1;81281:37:0::1;81273:67;;;::::0;-1:-1:-1;;;81273:67:0;;18020:2:1;81273:67:0::1;::::0;::::1;18002:21:1::0;18059:2;18039:18;;;18032:30;-1:-1:-1;;;18078:18:1;;;18071:47;18135:18;;81273:67:0::1;17818:341:1::0;81273:67:0::1;81351:21;::::0;;;:11:::1;:21;::::0;;;;;:30;81187:202::o;86244:178::-;13807:13;:11;:13::i;:::-;86364:50:::1;86383:15;86400:13;86364:18;:50::i;78367:28::-:0;;;;;;;:::i;80889:98::-;13807:13;:11;:13::i;:::-;80958:9:::1;:21:::0;80889:98::o;85421:208::-;85552:8;9303:30;9324:8;9303:20;:30::i;:::-;85578:43:::1;85602:8;85612;85578:23;:43::i;80027:101::-:0;13807:13;:11;:13::i;:::-;80096:12:::1;:24:::0;;-1:-1:-1;;80096:24:0::1;::::0;::::1;;::::0;;;::::1;::::0;;80027:101::o;80386:235::-;80508:28;;-1:-1:-1;;80525:10:0;20517:2:1;20513:15;20509:53;80508:28:0;;;20497:66:1;80466:4:0;;;;20579:12:1;;80508:28:0;;;;;;;;;;;;80498:39;;;;;;80483:54;;80555:58;80582:12;;80596:10;;80608:4;80555:26;:58::i;:::-;80548:65;80386:235;-1:-1:-1;;;;80386:235:0:o;85292:121::-;13807:13;:11;:13::i;:::-;85372:24:::1;:33:::0;;-1:-1:-1;;85372:33:0::1;::::0;::::1;;::::0;;;::::1;::::0;;85292:121::o;80753:114::-;13807:13;:11;:13::i;:::-;80830:11:::1;:29:::0;80753:114::o;80643:102::-;13807:13;:11;:13::i;:::-;80714:8:::1;:23:::0;80643:102::o;86759:119::-;86813:13;86850:20;:18;:20::i;:::-;86843:27;;86759:119;:::o;85637:272::-;85829:4;-1:-1:-1;;;;;9123:18:0;;9131:10;9123:18;9119:83;;9158:32;9179:10;9158:20;:32::i;:::-;85846:55:::1;85869:4;85875:2;85879:7;85888:6;85896:4;85846:22;:55::i;14827:201::-:0;13807:13;:11;:13::i;:::-;-1:-1:-1;;;;;14916:22:0;::::1;14908:73;;;::::0;-1:-1:-1;;;14908:73:0;;20804:2:1;14908:73:0::1;::::0;::::1;20786:21:1::0;20843:2;20823:18;;;20816:30;20882:34;20862:18;;;20855:62;-1:-1:-1;;;20933:18:1;;;20926:36;20979:19;;14908:73:0::1;20602:402:1::0;14908:73:0::1;14992:28;15011:8;14992:18;:28::i;:::-;14827:201:::0;:::o;55615:310::-;55717:4;-1:-1:-1;;;;;;55754:41:0;;-1:-1:-1;;;55754:41:0;;:110;;-1:-1:-1;;;;;;;55812:52:0;;-1:-1:-1;;;55812:52:0;55754:110;:163;;;-1:-1:-1;;;;;;;;;;33398:40:0;;;55881:36;33289:157;34843:215;34945:4;-1:-1:-1;;;;;;34969:41:0;;-1:-1:-1;;;34969:41:0;;:81;;;35014:36;35038:11;35014:23;:36::i;81397:1615::-;81467:7;81487:20;81545:15;81562:16;81580:25;:15;11282:14;;11190:114;81580:25;81528:84;;;;;;21222:19:1;;;;21257:12;;21250:28;;;;21294:12;;;21287:28;21331:12;;;21324:28;;;21368:13;;81528:84:0;;;-1:-1:-1;;81528:84:0;;;;;;;;;81518:95;;81528:84;81518:95;;;;;-1:-1:-1;81510:104:0;81647:26;79190:5;81518:95;81647:26;:::i;:::-;81625:48;-1:-1:-1;81684:24:0;81711:25;79143:1;81625:48;81711:25;:::i;:::-;81776:14;;;-1:-1:-1;;;;;;;;;;;81776:14:0;81753:17;81776:14;81753:20;-1:-1:-1;;;;;;;;;;;81753:20:0;81684:52;;-1:-1:-1;;81753:78:0;;;;-1:-1:-1;81829:1:0;81817:14;;-1:-1:-1;;;;;;;;;;;81817:14:0;81794:17;81817:14;81794:20;-1:-1:-1;;;;;;;;;;;81794:20:0;:37;81753:78;:119;;;;-1:-1:-1;81870:1:0;81858:14;;-1:-1:-1;;;;;;;;;;;81858:14:0;81835:17;81858:14;81835:20;-1:-1:-1;;;;;;;;;;;81835:20:0;:37;81753:119;81749:175;;;81896:16;81397:1615;-1:-1:-1;;;;81397:1615:0:o;81749:175::-;81939:16;81959:1;81939:21;81936:337;;82003:14;;;-1:-1:-1;;;;;;;;;;;82003:14:0;81980:17;82003:14;81980:20;-1:-1:-1;;;;;;;;;;;81980:20:0;:37;81976:86;;;-1:-1:-1;82045:1:0;;81397:1615;-1:-1:-1;;;;81397:1615:0:o;81976:86::-;82115:1;82103:14;;-1:-1:-1;;;;;;;;;;;82103:14:0;82080:17;82103:14;82080:20;-1:-1:-1;;;;;;;;;;;82080:20:0;:37;82076:86;;;-1:-1:-1;82145:1:0;;81397:1615;-1:-1:-1;;;;81397:1615:0:o;82076:86::-;82215:1;82203:14;;-1:-1:-1;;;;;;;;;;;82203:14:0;82180:17;82203:14;82180:20;-1:-1:-1;;;;;;;;;;;82180:20:0;:37;82176:86;;;-1:-1:-1;82245:1:0;;81397:1615;-1:-1:-1;;;;81397:1615:0:o;82176:86::-;82286:16;82306:1;82286:21;82283:337;;82362:1;82350:14;;-1:-1:-1;;;;;;;;;;;82350:14:0;82327:17;82350:14;82327:20;-1:-1:-1;;;;;;;;;;;82327:20:0;:37;82323:86;;;-1:-1:-1;82392:1:0;;81397:1615;-1:-1:-1;;;;81397:1615:0:o;82323:86::-;82450:14;;;-1:-1:-1;;;;;;;;;;;82450:14:0;82427:17;82450:14;82427:20;-1:-1:-1;;;;;;;;;;;82427:20:0;:37;82423:86;;;-1:-1:-1;82492:1:0;;81397:1615;-1:-1:-1;;;;81397:1615:0:o;82423:86::-;82562:1;82550:14;;-1:-1:-1;;;;;;;;;;;82550:14:0;82527:17;82550:14;82527:20;-1:-1:-1;;;;;;;;;;;82527:20:0;:37;82523:86;;;-1:-1:-1;82592:1:0;;81397:1615;-1:-1:-1;;;;81397:1615:0:o;82523:86::-;82635:16;82655:1;82635:21;82632:337;;82711:1;82699:14;;-1:-1:-1;;;;;;;;;;;82699:14:0;82676:17;82699:14;82676:20;-1:-1:-1;;;;;;;;;;;82676:20:0;:37;82672:86;;;-1:-1:-1;82741:1:0;;81397:1615;-1:-1:-1;;;;81397:1615:0:o;82672:86::-;82799:14;;;-1:-1:-1;;;;;;;;;;;82799:14:0;82776:17;82799:14;82776:20;-1:-1:-1;;;;;;;;;;;82776:20:0;:37;82772:86;;;-1:-1:-1;82841:1:0;;81397:1615;-1:-1:-1;;;;81397:1615:0:o;82772:86::-;82911:1;82899:14;;-1:-1:-1;;;;;;;;;;;82899:14:0;82876:17;82899:14;82876:20;-1:-1:-1;;;;;;;;;;;82876:20:0;:37;82872:86;;;-1:-1:-1;82941:1:0;;81397:1615;-1:-1:-1;;;;81397:1615:0:o;63233:729::-;-1:-1:-1;;;;;63386:16:0;;63378:62;;;;-1:-1:-1;;;63378:62:0;;21711:2:1;63378:62:0;;;21693:21:1;21750:2;21730:18;;;21723:30;21789:34;21769:18;;;21762:62;-1:-1:-1;;;21840:18:1;;;21833:31;21881:19;;63378:62:0;21509:397:1;63378:62:0;12548:10;63453:16;63518:21;63536:2;63518:17;:21::i;:::-;63495:44;;63550:24;63577:25;63595:6;63577:17;:25::i;:::-;63550:52;;63694:9;:13;;;;;;;;;;;-1:-1:-1;;;;;63694:17:0;;;;;;;;;:27;;63715:6;;63694:9;:27;;63715:6;;63694:27;:::i;:::-;;;;-1:-1:-1;;63737:52:0;;;22085:25:1;;;22141:2;22126:18;;22119:34;;;-1:-1:-1;;;;;63737:52:0;;;;63770:1;;63737:52;;;;;;22058:18:1;63737:52:0;;;;;;;63880:74;63911:8;63929:1;63933:2;63937;63941:6;63949:4;63880:30;:74::i;:::-;63367:595;;;63233:729;;;;:::o;9361:447::-;7882:42;9552:45;:49;;;;:77;;-1:-1:-1;9605:24:0;;;;9552:77;9548:253;;;9651:67;;-1:-1:-1;;;9651:67:0;;9702:4;9651:67;;;22376:34:1;-1:-1:-1;;;;;22446:15:1;;22426:18;;;22419:43;7882:42:0;;9651;;22311:18:1;;9651:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9646:144;;9746:28;;-1:-1:-1;;;9746:28:0;;-1:-1:-1;;;;;6897:32:1;;9746:28:0;;;6879:51:1;6852:18;;9746:28:0;6702:234:1;58535:438:0;-1:-1:-1;;;;;58768:20:0;;12548:10;58768:20;;:60;;-1:-1:-1;58792:36:0;58809:4;12548:10;57812:168;:::i;58792:36::-;58746:156;;;;-1:-1:-1;;;58746:156:0;;;;;;;:::i;:::-;58913:52;58936:4;58942:2;58946:3;58951:7;58960:4;58913:22;:52::i;:::-;58535:438;;;;;:::o;14086:132::-;13994:6;;-1:-1:-1;;;;;13994:6:0;12548:10;14150:23;14142:68;;;;-1:-1:-1;;;14142:68:0;;23340:2:1;14142:68:0;;;23322:21:1;;;23359:18;;;23352:30;23418:34;23398:18;;;23391:62;23470:18;;14142:68:0;23138:356:1;77942:150:0;77722:1;78000:7;;:19;77992:63;;;;-1:-1:-1;;;77992:63:0;;23701:2:1;77992:63:0;;;23683:21:1;23740:2;23720:18;;;23713:30;23779:33;23759:18;;;23752:61;23830:18;;77992:63:0;23499:355:1;77992:63:0;77722:1;78066:7;:18;77942:150::o;15188:191::-;15281:6;;;-1:-1:-1;;;;;15298:17:0;;;-1:-1:-1;;;;;;15298:17:0;;;;;;;15331:40;;15281:6;;;15298:17;15281:6;;15331:40;;15262:16;;15331:40;15251:128;15188:191;:::o;36205:332::-;35921:5;-1:-1:-1;;;;;36308:33:0;;;;36300:88;;;;-1:-1:-1;;;36300:88:0;;24061:2:1;36300:88:0;;;24043:21:1;24100:2;24080:18;;;24073:30;24139:34;24119:18;;;24112:62;-1:-1:-1;;;24190:18:1;;;24183:40;24240:19;;36300:88:0;23859:406:1;36300:88:0;-1:-1:-1;;;;;36407:22:0;;36399:60;;;;-1:-1:-1;;;36399:60:0;;24472:2:1;36399:60:0;;;24454:21:1;24511:2;24491:18;;;24484:30;24550:27;24530:18;;;24523:55;24595:18;;36399:60:0;24270:349:1;36399:60:0;36494:35;;;;;;;;;-1:-1:-1;;;;;36494:35:0;;;;;;-1:-1:-1;;;;;36494:35:0;;;;;;;;;;-1:-1:-1;;;36472:57:0;;;;:19;:57;36205:332::o;57585:155::-;57680:52;12548:10;57713:8;57723;57680:18;:52::i;73530:208::-;73665:4;73726;73689:33;73710:5;;73717:4;73689:20;:33::i;:::-;:41;;73530:208;-1:-1:-1;;;;;73530:208:0:o;86908:617::-;86961:13;86988:16;;87033:32;86988:16;35921:5;87033:11;:32::i;:::-;86987:78;;;;87188:307;87310:33;87327:15;87310:16;:33::i;:::-;87389:51;87425:8;-1:-1:-1;;;;;87409:26:0;87437:2;87389:19;:51::i;:::-;87240:225;;;;;;;;;:::i;:::-;;;;;;;;;;;;;87188:13;:307::i;:::-;87111:395;;;;;;;;:::i;:::-;;;;;;;;;;;;;87087:430;;;;86908:617;:::o;58052:406::-;-1:-1:-1;;;;;58260:20:0;;12548:10;58260:20;;:60;;-1:-1:-1;58284:36:0;58301:4;12548:10;57812:168;:::i;58284:36::-;58238:156;;;;-1:-1:-1;;;58238:156:0;;;;;;;:::i;:::-;58405:45;58423:4;58429:2;58433;58437:6;58445:4;58405:17;:45::i;71912:198::-;72032:16;;;72046:1;72032:16;;;;;;;;;71978;;72007:22;;72032:16;;;;;;;;;;;;-1:-1:-1;72032:16:0;72007:41;;72070:7;72059:5;72065:1;72059:8;;;;;;;;:::i;:::-;;;;;;;;;;:18;72097:5;71912:198;-1:-1:-1;;71912:198:0:o;70339:744::-;-1:-1:-1;;;;;70554:13:0;;45889:19;:23;70550:526;;70590:72;;-1:-1:-1;;;70590:72:0;;-1:-1:-1;;;;;70590:38:0;;;;;:72;;70629:8;;70639:4;;70645:2;;70649:6;;70657:4;;70590:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;70590:72:0;;;;;;;;-1:-1:-1;;70590:72:0;;;;;;;;;;;;:::i;:::-;;;70586:479;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;70938:6;70931:14;;-1:-1:-1;;;70931:14:0;;;;;;;;:::i;70586:479::-;;;70987:62;;-1:-1:-1;;;70987:62:0;;28027:2:1;70987:62:0;;;28009:21:1;28066:2;28046:18;;;28039:30;28105:34;28085:18;;;28078:62;-1:-1:-1;;;28156:18:1;;;28149:50;28216:19;;70987:62:0;27825:416:1;70586:479:0;-1:-1:-1;;;;;;70712:55:0;;-1:-1:-1;;;70712:55:0;70708:154;;70792:50;;-1:-1:-1;;;70792:50:0;;;;;;;:::i;60769:1146::-;60996:7;:14;60982:3;:10;:28;60974:81;;;;-1:-1:-1;;;60974:81:0;;28857:2:1;60974:81:0;;;28839:21:1;28896:2;28876:18;;;28869:30;28935:34;28915:18;;;28908:62;-1:-1:-1;;;28986:18:1;;;28979:38;29034:19;;60974:81:0;28655:404:1;60974:81:0;-1:-1:-1;;;;;61074:16:0;;61066:66;;;;-1:-1:-1;;;61066:66:0;;;;;;;:::i;:::-;12548:10;61145:16;61262:421;61286:3;:10;61282:1;:14;61262:421;;;61318:10;61331:3;61335:1;61331:6;;;;;;;;:::i;:::-;;;;;;;61318:19;;61352:14;61369:7;61377:1;61369:10;;;;;;;;:::i;:::-;;;;;;;;;;;;61396:19;61418:13;;;;;;;;;;-1:-1:-1;;;;;61418:19:0;;;;;;;;;;;;61369:10;;-1:-1:-1;61460:21:0;;;;61452:76;;;;-1:-1:-1;;;61452:76:0;;;;;;;:::i;:::-;61572:9;:13;;;;;;;;;;;-1:-1:-1;;;;;61572:19:0;;;;;;;;;;61594:20;;;61572:42;;61644:17;;;;;;;:27;;61594:20;;61572:9;61644:27;;61594:20;;61644:27;:::i;:::-;;;;;;;;61303:380;;;61298:3;;;;:::i;:::-;;;61262:421;;;;61730:2;-1:-1:-1;;;;;61700:47:0;61724:4;-1:-1:-1;;;;;61700:47:0;61714:8;-1:-1:-1;;;;;61700:47:0;;61734:3;61739:7;61700:47;;;;;;;:::i;:::-;;;;;;;;61832:75;61868:8;61878:4;61884:2;61888:3;61893:7;61902:4;61832:35;:75::i;67646:331::-;67801:8;-1:-1:-1;;;;;67792:17:0;:5;-1:-1:-1;;;;;67792:17:0;;67784:71;;;;-1:-1:-1;;;67784:71:0;;30553:2:1;67784:71:0;;;30535:21:1;30592:2;30572:18;;;30565:30;30631:34;30611:18;;;30604:62;-1:-1:-1;;;30682:18:1;;;30675:39;30731:19;;67784:71:0;30351:405:1;67784:71:0;-1:-1:-1;;;;;67866:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;67866:46:0;;;;;;;;;;67928:41;;1159::1;;;67928::0;;1132:18:1;67928:41:0;;;;;;;67646:331;;;:::o;74050:306::-;74143:7;74186:4;74143:7;74201:118;74221:16;;;74201:118;;;74274:33;74284:12;74298:5;;74304:1;74298:8;;;;;;;:::i;:::-;;;;;;;74274:9;:33::i;:::-;74259:48;-1:-1:-1;74239:3:0;;;;:::i;:::-;;;;74201:118;;;-1:-1:-1;74336:12:0;74050:306;-1:-1:-1;;;;74050:306:0:o;28701:716::-;28757:13;28808:14;28825:17;28836:5;28825:10;:17::i;:::-;28845:1;28825:21;28808:38;;28861:20;28895:6;-1:-1:-1;;;;;28884:18:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28884:18:0;-1:-1:-1;28861:41:0;-1:-1:-1;29026:28:0;;;29042:2;29026:28;29083:288;-1:-1:-1;;29115:5:0;-1:-1:-1;;;29252:2:0;29241:14;;29236:30;29115:5;29223:44;29313:2;29304:11;;;-1:-1:-1;29334:21:0;29083:288;29334:21;-1:-1:-1;29392:6:0;28701:716;-1:-1:-1;;;28701:716:0:o;29833:447::-;29908:13;29934:19;29966:10;29970:6;29966:1;:10;:::i;:::-;:14;;29979:1;29966:14;:::i;:::-;-1:-1:-1;;;;;29956:25:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;29956:25:0;;29934:47;;-1:-1:-1;;;29992:6:0;29999:1;29992:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;29992:15:0;;;;;;;;;-1:-1:-1;;;30018:6:0;30025:1;30018:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;30018:15:0;;;;;;;;-1:-1:-1;30049:9:0;30061:10;30065:6;30061:1;:10;:::i;:::-;:14;;30074:1;30061:14;:::i;:::-;30049:26;;30044:131;30081:1;30077;:5;30044:131;;;-1:-1:-1;;;30125:5:0;30133:3;30125:11;30116:21;;;;;;;:::i;:::-;;;;30104:6;30111:1;30104:9;;;;;;;;:::i;:::-;;;;:33;-1:-1:-1;;;;;30104:33:0;;;;;;;;-1:-1:-1;30162:1:0;30152:11;;;;;30084:3;;;:::i;:::-;;;30044:131;;;-1:-1:-1;30193:10:0;;30185:55;;;;-1:-1:-1;;;30185:55:0;;31104:2:1;30185:55:0;;;31086:21:1;;;31123:18;;;31116:30;31182:34;31162:18;;;31155:62;31234:18;;30185:55:0;30902:356:1;30185:55:0;30265:6;29833:447;-1:-1:-1;;;29833:447:0:o;706:1912::-;764:13;794:4;:11;809:1;794:16;790:31;;-1:-1:-1;;812:9:0;;;;;;;;;-1:-1:-1;812:9:0;;;706:1912::o;790:31::-;873:19;895:12;;;;;;;;;;;;;;;;;873:34;;959:18;1005:1;986:4;:11;1000:1;986:15;;;;:::i;:::-;985:21;;;;:::i;:::-;980:27;;:1;:27;:::i;:::-;959:48;-1:-1:-1;1090:20:0;1124:15;959:48;1137:2;1124:15;:::i;:::-;-1:-1:-1;;;;;1113:27:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1113:27:0;;1090:50;;1237:10;1229:6;1222:26;1332:1;1325:5;1321:13;1391:4;1442;1436:11;1427:7;1423:25;1538:2;1530:6;1526:15;1611:754;1630:6;1621:7;1618:19;1611:754;;;1730:1;1721:7;1717:15;1706:26;;1769:7;1763:14;1895:4;1887:5;1883:2;1879:14;1875:25;1865:8;1861:40;1855:47;1844:9;1836:67;1949:1;1938:9;1934:17;1921:30;;2028:4;2020:5;2016:2;2012:14;2008:25;1998:8;1994:40;1988:47;1977:9;1969:67;2082:1;2071:9;2067:17;2054:30;;2161:4;2153:5;2150:1;2145:14;2141:25;2131:8;2127:40;2121:47;2110:9;2102:67;2215:1;2204:9;2200:17;2187:30;;2294:4;2286:5;2274:25;2264:8;2260:40;2254:47;2243:9;2235:67;-1:-1:-1;2348:1:0;2333:17;1611:754;;;2438:1;2431:4;2425:11;2421:19;2459:1;2454:54;;;;2527:1;2522:52;;;;2414:160;;2454:54;-1:-1:-1;;;;;2470:17:0;;2463:43;2454:54;;2522:52;-1:-1:-1;;;;;2538:17:0;;2531:41;2414:160;-1:-1:-1;2604:6:0;;706:1912;-1:-1:-1;;;;;;;;706:1912:0:o;59437:974::-;-1:-1:-1;;;;;59625:16:0;;59617:66;;;;-1:-1:-1;;;59617:66:0;;;;;;;:::i;:::-;12548:10;59696:16;59761:21;59779:2;59761:17;:21::i;:::-;59738:44;;59793:24;59820:25;59838:6;59820:17;:25::i;:::-;59793:52;;59931:19;59953:13;;;;;;;;;;;-1:-1:-1;;;;;59953:19:0;;;;;;;;;;59991:21;;;;59983:76;;;;-1:-1:-1;;;59983:76:0;;;;;;;:::i;:::-;60095:9;:13;;;;;;;;;;;-1:-1:-1;;;;;60095:19:0;;;;;;;;;;60117:20;;;60095:42;;60159:17;;;;;;;:27;;60117:20;;60095:9;60159:27;;60117:20;;60159:27;:::i;:::-;;;;-1:-1:-1;;60204:46:0;;;22085:25:1;;;22141:2;22126:18;;22119:34;;;-1:-1:-1;;;;;60204:46:0;;;;;;;;;;;;;;22058:18:1;60204:46:0;;;;;;;60335:68;60366:8;60376:4;60382:2;60386;60390:6;60398:4;60335:30;:68::i;:::-;59606:805;;;;59437:974;;;;;:::o;71091:813::-;-1:-1:-1;;;;;71331:13:0;;45889:19;:23;71327:570;;71367:79;;-1:-1:-1;;;71367:79:0;;-1:-1:-1;;;;;71367:43:0;;;;;:79;;71411:8;;71421:4;;71427:3;;71432:7;;71441:4;;71367:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71367:79:0;;;;;;;;-1:-1:-1;;71367:79:0;;;;;;;;;;;;:::i;:::-;;;71363:523;;;;:::i;:::-;-1:-1:-1;;;;;;71528:60:0;;-1:-1:-1;;;71528:60:0;71524:159;;71613:50;;-1:-1:-1;;;71613:50:0;;;;;;;:::i;77138:149::-;77201:7;77232:1;77228;:5;:51;;77363:13;77457:15;;;77493:4;77486:15;;;77540:4;77524:21;;77228:51;;;77363:13;77457:15;;;77493:4;77486:15;;;77540:4;77524:21;;77236:20;77295:268;25563:922;25616:7;;-1:-1:-1;;;25694:15:0;;25690:102;;-1:-1:-1;;;25730:15:0;;;-1:-1:-1;25774:2:0;25764:12;25690:102;25819:6;25810:5;:15;25806:102;;25855:6;25846:15;;;-1:-1:-1;25890:2:0;25880:12;25806:102;25935:6;25926:5;:15;25922:102;;25971:6;25962:15;;;-1:-1:-1;26006:2:0;25996:12;25922:102;26051:5;26042;:14;26038:99;;26086:5;26077:14;;;-1:-1:-1;26120:1:0;26110:11;26038:99;26164:5;26155;:14;26151:99;;26199:5;26190:14;;;-1:-1:-1;26233:1:0;26223:11;26151:99;26277:5;26268;:14;26264:99;;26312:5;26303:14;;;-1:-1:-1;26346:1:0;26336:11;26264:99;26390:5;26381;:14;26377:66;;26426:1;26416:11;26471:6;25563:922;-1:-1:-1;;25563:922:0:o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:254::-;260:6;268;321:2;309:9;300:7;296:23;292:32;289:52;;;337:1;334;327:12;289:52;360:29;379:9;360:29;:::i;:::-;350:39;436:2;421:18;;;;408:32;;-1:-1:-1;;;192:254:1:o;633:131::-;-1:-1:-1;;;;;;707:32:1;;697:43;;687:71;;754:1;751;744:12;769:245;827:6;880:2;868:9;859:7;855:23;851:32;848:52;;;896:1;893;886:12;848:52;935:9;922:23;954:30;978:5;954:30;:::i;1211:250::-;1296:1;1306:113;1320:6;1317:1;1314:13;1306:113;;;1396:11;;;1390:18;1377:11;;;1370:39;1342:2;1335:10;1306:113;;;-1:-1:-1;;1453:1:1;1435:16;;1428:27;1211:250::o;1466:271::-;1508:3;1546:5;1540:12;1573:6;1568:3;1561:19;1589:76;1658:6;1651:4;1646:3;1642:14;1635:4;1628:5;1624:16;1589:76;:::i;:::-;1719:2;1698:15;-1:-1:-1;;1694:29:1;1685:39;;;;1726:4;1681:50;;1466:271;-1:-1:-1;;1466:271:1:o;1742:220::-;1891:2;1880:9;1873:21;1854:4;1911:45;1952:2;1941:9;1937:18;1929:6;1911:45;:::i;1967:180::-;2026:6;2079:2;2067:9;2058:7;2054:23;2050:32;2047:52;;;2095:1;2092;2085:12;2047:52;-1:-1:-1;2118:23:1;;1967:180;-1:-1:-1;1967:180:1:o;2152:186::-;2211:6;2264:2;2252:9;2243:7;2239:23;2235:32;2232:52;;;2280:1;2277;2270:12;2232:52;2303:29;2322:9;2303:29;:::i;2343:248::-;2411:6;2419;2472:2;2460:9;2451:7;2447:23;2443:32;2440:52;;;2488:1;2485;2478:12;2440:52;-1:-1:-1;;2511:23:1;;;2581:2;2566:18;;;2553:32;;-1:-1:-1;2343:248:1:o;2875:127::-;2936:10;2931:3;2927:20;2924:1;2917:31;2967:4;2964:1;2957:15;2991:4;2988:1;2981:15;3007:249;3117:2;3098:13;;-1:-1:-1;;3094:27:1;3082:40;;-1:-1:-1;;;;;3137:34:1;;3173:22;;;3134:62;3131:88;;;3199:18;;:::i;:::-;3235:2;3228:22;-1:-1:-1;;3007:249:1:o;3261:183::-;3321:4;-1:-1:-1;;;;;3346:6:1;3343:30;3340:56;;;3376:18;;:::i;:::-;-1:-1:-1;3421:1:1;3417:14;3433:4;3413:25;;3261:183::o;3449:724::-;3503:5;3556:3;3549:4;3541:6;3537:17;3533:27;3523:55;;3574:1;3571;3564:12;3523:55;3610:6;3597:20;3636:4;3659:43;3699:2;3659:43;:::i;:::-;3731:2;3725:9;3743:31;3771:2;3763:6;3743:31;:::i;:::-;3809:18;;;3901:1;3897:10;;;;3885:23;;3881:32;;;3843:15;;;;-1:-1:-1;3925:15:1;;;3922:35;;;3953:1;3950;3943:12;3922:35;3989:2;3981:6;3977:15;4001:142;4017:6;4012:3;4009:15;4001:142;;;4083:17;;4071:30;;4121:12;;;;4034;;4001:142;;;-1:-1:-1;4161:6:1;3449:724;-1:-1:-1;;;;;;3449:724:1:o;4178:468::-;4242:5;-1:-1:-1;;;;;4268:6:1;4265:30;4262:56;;;4298:18;;:::i;:::-;4347:2;4341:9;4359:69;4416:2;4395:15;;-1:-1:-1;;4391:29:1;4422:4;4387:40;4341:9;4359:69;:::i;:::-;4446:6;4437:15;;4476:6;4468;4461:22;4516:3;4507:6;4502:3;4498:16;4495:25;4492:45;;;4533:1;4530;4523:12;4492:45;4583:6;4578:3;4571:4;4563:6;4559:17;4546:44;4638:1;4631:4;4622:6;4614;4610:19;4606:30;4599:41;;4178:468;;;;;:::o;4651:220::-;4693:5;4746:3;4739:4;4731:6;4727:17;4723:27;4713:55;;4764:1;4761;4754:12;4713:55;4786:79;4861:3;4852:6;4839:20;4832:4;4824:6;4820:17;4786:79;:::i;4876:943::-;5030:6;5038;5046;5054;5062;5115:3;5103:9;5094:7;5090:23;5086:33;5083:53;;;5132:1;5129;5122:12;5083:53;5155:29;5174:9;5155:29;:::i;:::-;5145:39;;5203:38;5237:2;5226:9;5222:18;5203:38;:::i;:::-;5193:48;;5292:2;5281:9;5277:18;5264:32;-1:-1:-1;;;;;5356:2:1;5348:6;5345:14;5342:34;;;5372:1;5369;5362:12;5342:34;5395:61;5448:7;5439:6;5428:9;5424:22;5395:61;:::i;:::-;5385:71;;5509:2;5498:9;5494:18;5481:32;5465:48;;5538:2;5528:8;5525:16;5522:36;;;5554:1;5551;5544:12;5522:36;5577:63;5632:7;5621:8;5610:9;5606:24;5577:63;:::i;:::-;5567:73;;5693:3;5682:9;5678:19;5665:33;5649:49;;5723:2;5713:8;5710:16;5707:36;;;5739:1;5736;5729:12;5707:36;;5762:51;5805:7;5794:8;5783:9;5779:24;5762:51;:::i;:::-;5752:61;;;4876:943;;;;;;;;:::o;6006:322::-;6083:6;6091;6099;6152:2;6140:9;6131:7;6127:23;6123:32;6120:52;;;6168:1;6165;6158:12;6120:52;6191:29;6210:9;6191:29;:::i;:::-;6181:39;6267:2;6252:18;;6239:32;;-1:-1:-1;6318:2:1;6303:18;;;6290:32;;6006:322;-1:-1:-1;;;6006:322:1:o;6333:118::-;6419:5;6412:13;6405:21;6398:5;6395:32;6385:60;;6441:1;6438;6431:12;6456:241;6512:6;6565:2;6553:9;6544:7;6540:23;6536:32;6533:52;;;6581:1;6578;6571:12;6533:52;6620:9;6607:23;6639:28;6661:5;6639:28;:::i;6941:1208::-;7059:6;7067;7120:2;7108:9;7099:7;7095:23;7091:32;7088:52;;;7136:1;7133;7126:12;7088:52;7176:9;7163:23;-1:-1:-1;;;;;7246:2:1;7238:6;7235:14;7232:34;;;7262:1;7259;7252:12;7232:34;7300:6;7289:9;7285:22;7275:32;;7345:7;7338:4;7334:2;7330:13;7326:27;7316:55;;7367:1;7364;7357:12;7316:55;7403:2;7390:16;7425:4;7448:43;7488:2;7448:43;:::i;:::-;7520:2;7514:9;7532:31;7560:2;7552:6;7532:31;:::i;:::-;7598:18;;;7686:1;7682:10;;;;7674:19;;7670:28;;;7632:15;;;;-1:-1:-1;7710:19:1;;;7707:39;;;7742:1;7739;7732:12;7707:39;7766:11;;;;7786:148;7802:6;7797:3;7794:15;7786:148;;;7868:23;7887:3;7868:23;:::i;:::-;7856:36;;7819:12;;;;7912;;;;7786:148;;;7953:6;-1:-1:-1;;7997:18:1;;7984:32;;-1:-1:-1;;8028:16:1;;;8025:36;;;8057:1;8054;8047:12;8025:36;;8080:63;8135:7;8124:8;8113:9;8109:24;8080:63;:::i;:::-;8070:73;;;6941:1208;;;;;:::o;8154:435::-;8207:3;8245:5;8239:12;8272:6;8267:3;8260:19;8298:4;8327:2;8322:3;8318:12;8311:19;;8364:2;8357:5;8353:14;8385:1;8395:169;8409:6;8406:1;8403:13;8395:169;;;8470:13;;8458:26;;8504:12;;;;8539:15;;;;8431:1;8424:9;8395:169;;;-1:-1:-1;8580:3:1;;8154:435;-1:-1:-1;;;;;8154:435:1:o;8594:261::-;8773:2;8762:9;8755:21;8736:4;8793:56;8845:2;8834:9;8830:18;8822:6;8793:56;:::i;8860:367::-;8923:8;8933:6;8987:3;8980:4;8972:6;8968:17;8964:27;8954:55;;9005:1;9002;8995:12;8954:55;-1:-1:-1;9028:20:1;;-1:-1:-1;;;;;9060:30:1;;9057:50;;;9103:1;9100;9093:12;9057:50;9140:4;9132:6;9128:17;9116:29;;9200:3;9193:4;9183:6;9180:1;9176:14;9168:6;9164:27;9160:38;9157:47;9154:67;;;9217:1;9214;9207:12;9232:505;9327:6;9335;9343;9396:2;9384:9;9375:7;9371:23;9367:32;9364:52;;;9412:1;9409;9402:12;9364:52;9448:9;9435:23;9425:33;;9509:2;9498:9;9494:18;9481:32;-1:-1:-1;;;;;9528:6:1;9525:30;9522:50;;;9568:1;9565;9558:12;9522:50;9607:70;9669:7;9660:6;9649:9;9645:22;9607:70;:::i;:::-;9232:505;;9696:8;;-1:-1:-1;9581:96:1;;-1:-1:-1;;;;9232:505:1:o;9927:518::-;10005:6;10013;10066:2;10054:9;10045:7;10041:23;10037:32;10034:52;;;10082:1;10079;10072:12;10034:52;10118:9;10105:23;10095:33;;10179:2;10168:9;10164:18;10151:32;-1:-1:-1;;;;;10198:6:1;10195:30;10192:50;;;10238:1;10235;10228:12;10192:50;10261:22;;10314:4;10306:13;;10302:27;-1:-1:-1;10292:55:1;;10343:1;10340;10333:12;10292:55;10366:73;10431:7;10426:2;10413:16;10408:2;10404;10400:11;10366:73;:::i;10658:366::-;10725:6;10733;10786:2;10774:9;10765:7;10761:23;10757:32;10754:52;;;10802:1;10799;10792:12;10754:52;10825:29;10844:9;10825:29;:::i;:::-;10815:39;;10904:2;10893:9;10889:18;10876:32;-1:-1:-1;;;;;10941:5:1;10937:38;10930:5;10927:49;10917:77;;10990:1;10987;10980:12;10917:77;11013:5;11003:15;;;10658:366;;;;;:::o;11029:315::-;11094:6;11102;11155:2;11143:9;11134:7;11130:23;11126:32;11123:52;;;11171:1;11168;11161:12;11123:52;11194:29;11213:9;11194:29;:::i;:::-;11184:39;;11273:2;11262:9;11258:18;11245:32;11286:28;11308:5;11286:28;:::i;11349:437::-;11435:6;11443;11496:2;11484:9;11475:7;11471:23;11467:32;11464:52;;;11512:1;11509;11502:12;11464:52;11552:9;11539:23;-1:-1:-1;;;;;11577:6:1;11574:30;11571:50;;;11617:1;11614;11607:12;11571:50;11656:70;11718:7;11709:6;11698:9;11694:22;11656:70;:::i;:::-;11745:8;;11630:96;;-1:-1:-1;11349:437:1;-1:-1:-1;;;;11349:437:1:o;11791:260::-;11859:6;11867;11920:2;11908:9;11899:7;11895:23;11891:32;11888:52;;;11936:1;11933;11926:12;11888:52;11959:29;11978:9;11959:29;:::i;:::-;11949:39;;12007:38;12041:2;12030:9;12026:18;12007:38;:::i;:::-;11997:48;;11791:260;;;;;:::o;12056:606::-;12160:6;12168;12176;12184;12192;12245:3;12233:9;12224:7;12220:23;12216:33;12213:53;;;12262:1;12259;12252:12;12213:53;12285:29;12304:9;12285:29;:::i;:::-;12275:39;;12333:38;12367:2;12356:9;12352:18;12333:38;:::i;:::-;12323:48;;12418:2;12407:9;12403:18;12390:32;12380:42;;12469:2;12458:9;12454:18;12441:32;12431:42;;12524:3;12513:9;12509:19;12496:33;-1:-1:-1;;;;;12544:6:1;12541:30;12538:50;;;12584:1;12581;12574:12;12538:50;12607:49;12648:7;12639:6;12628:9;12624:22;12607:49;:::i;13078:380::-;13157:1;13153:12;;;;13200;;;13221:61;;13275:4;13267:6;13263:17;13253:27;;13221:61;13328:2;13320:6;13317:14;13297:18;13294:38;13291:161;;13374:10;13369:3;13365:20;13362:1;13355:31;13409:4;13406:1;13399:15;13437:4;13434:1;13427:15;13291:161;;13078:380;;;:::o;13463:127::-;13524:10;13519:3;13515:20;13512:1;13505:31;13555:4;13552:1;13545:15;13579:4;13576:1;13569:15;13595:168;13668:9;;;13699;;13716:15;;;13710:22;;13696:37;13686:71;;13737:18;;:::i;13768:127::-;13829:10;13824:3;13820:20;13817:1;13810:31;13860:4;13857:1;13850:15;13884:4;13881:1;13874:15;13900:120;13940:1;13966;13956:35;;13971:18;;:::i;:::-;-1:-1:-1;14005:9:1;;13900:120::o;14370:125::-;14435:9;;;14456:10;;;14453:36;;;14469:18;;:::i;14843:338::-;15045:2;15027:21;;;15084:2;15064:18;;;15057:30;-1:-1:-1;;;15118:2:1;15103:18;;15096:44;15172:2;15157:18;;14843:338::o;15540:135::-;15579:3;15600:17;;;15597:43;;15620:18;;:::i;:::-;-1:-1:-1;15667:1:1;15656:13;;15540:135::o;17337:127::-;17398:10;17393:3;17389:20;17386:1;17379:31;17429:4;17426:1;17419:15;17453:4;17450:1;17443:15;18290:545;18392:2;18387:3;18384:11;18381:448;;;18428:1;18453:5;18449:2;18442:17;18498:4;18494:2;18484:19;18568:2;18556:10;18552:19;18549:1;18545:27;18539:4;18535:38;18604:4;18592:10;18589:20;18586:47;;;-1:-1:-1;18627:4:1;18586:47;18682:2;18677:3;18673:12;18670:1;18666:20;18660:4;18656:31;18646:41;;18737:82;18755:2;18748:5;18745:13;18737:82;;;18800:17;;;18781:1;18770:13;18737:82;;19011:1352;19137:3;19131:10;-1:-1:-1;;;;;19156:6:1;19153:30;19150:56;;;19186:18;;:::i;:::-;19215:97;19305:6;19265:38;19297:4;19291:11;19265:38;:::i;:::-;19259:4;19215:97;:::i;:::-;19367:4;;19431:2;19420:14;;19448:1;19443:663;;;;20150:1;20167:6;20164:89;;;-1:-1:-1;20219:19:1;;;20213:26;20164:89;-1:-1:-1;;18968:1:1;18964:11;;;18960:24;18956:29;18946:40;18992:1;18988:11;;;18943:57;20266:81;;19413:944;;19443:663;18237:1;18230:14;;;18274:4;18261:18;;-1:-1:-1;;19479:20:1;;;19597:236;19611:7;19608:1;19605:14;19597:236;;;19700:19;;;19694:26;19679:42;;19792:27;;;;19760:1;19748:14;;;;19627:19;;19597:236;;;19601:3;19861:6;19852:7;19849:19;19846:201;;;19922:19;;;19916:26;-1:-1:-1;;20005:1:1;20001:14;;;20017:3;19997:24;19993:37;19989:42;19974:58;19959:74;;19846:201;-1:-1:-1;;;;;20093:1:1;20077:14;;;20073:22;20060:36;;-1:-1:-1;19011:1352:1:o;21392:112::-;21424:1;21450;21440:35;;21455:18;;:::i;:::-;-1:-1:-1;21489:9:1;;21392:112::o;22473:245::-;22540:6;22593:2;22581:9;22572:7;22568:23;22564:32;22561:52;;;22609:1;22606;22599:12;22561:52;22641:9;22635:16;22660:28;22682:5;22660:28;:::i;22723:410::-;22925:2;22907:21;;;22964:2;22944:18;;;22937:30;23003:34;22998:2;22983:18;;22976:62;-1:-1:-1;;;23069:2:1;23054:18;;23047:44;23123:3;23108:19;;22723:410::o;24624:1050::-;25136:66;25131:3;25124:79;25106:3;25232:6;25226:13;25248:75;25316:6;25311:2;25306:3;25302:12;25295:4;25287:6;25283:17;25248:75;:::i;:::-;-1:-1:-1;;;25382:2:1;25342:16;;;25374:11;;;25367:71;25463:13;;25485:76;25463:13;25547:2;25539:11;;25532:4;25520:17;;25485:76;:::i;:::-;-1:-1:-1;;;25621:2:1;25580:17;;;;25613:11;;;25606:35;25665:2;25657:11;;24624:1050;-1:-1:-1;;;;24624:1050:1:o;25679:461::-;25941:31;25936:3;25929:44;25911:3;26002:6;25996:13;26018:75;26086:6;26081:2;26076:3;26072:12;26065:4;26057:6;26053:17;26018:75;:::i;:::-;26113:16;;;;26131:2;26109:25;;25679:461;-1:-1:-1;;25679:461:1:o;26145:561::-;-1:-1:-1;;;;;26442:15:1;;;26424:34;;26494:15;;26489:2;26474:18;;26467:43;26541:2;26526:18;;26519:34;;;26584:2;26569:18;;26562:34;;;26404:3;26627;26612:19;;26605:32;;;26367:4;;26654:46;;26680:19;;26672:6;26654:46;:::i;:::-;26646:54;26145:561;-1:-1:-1;;;;;;;26145:561:1:o;26711:249::-;26780:6;26833:2;26821:9;26812:7;26808:23;26804:32;26801:52;;;26849:1;26846;26839:12;26801:52;26881:9;26875:16;26900:30;26924:5;26900:30;:::i;26965:179::-;27000:3;27042:1;27024:16;27021:23;27018:120;;;27088:1;27085;27082;27067:23;-1:-1:-1;27125:1:1;27119:8;27114:3;27110:18;27018:120;26965:179;:::o;27149:671::-;27188:3;27230:4;27212:16;27209:26;27206:39;;;27149:671;:::o;27206:39::-;27272:2;27266:9;-1:-1:-1;;27337:16:1;27333:25;;27330:1;27266:9;27309:50;27388:4;27382:11;27412:16;-1:-1:-1;;;;;27518:2:1;27511:4;27503:6;27499:17;27496:25;27491:2;27483:6;27480:14;27477:45;27474:58;;;27525:5;;;;;27149:671;:::o;27474:58::-;27562:6;27556:4;27552:17;27541:28;;27598:3;27592:10;27625:2;27617:6;27614:14;27611:27;;;27631:5;;;;;;27149:671;:::o;27611:27::-;27715:2;27696:16;27690:4;27686:27;27682:36;27675:4;27666:6;27661:3;27657:16;27653:27;27650:69;27647:82;;;27722:5;;;;;;27149:671;:::o;27647:82::-;27738:57;27789:4;27780:6;27772;27768:19;27764:30;27758:4;27738:57;:::i;:::-;-1:-1:-1;27811:3:1;;27149:671;-1:-1:-1;;;;;27149:671:1:o;28246:404::-;28448:2;28430:21;;;28487:2;28467:18;;;28460:30;28526:34;28521:2;28506:18;;28499:62;-1:-1:-1;;;28592:2:1;28577:18;;28570:38;28640:3;28625:19;;28246:404::o;29064:401::-;29266:2;29248:21;;;29305:2;29285:18;;;29278:30;29344:34;29339:2;29324:18;;29317:62;-1:-1:-1;;;29410:2:1;29395:18;;29388:35;29455:3;29440:19;;29064:401::o;29470:406::-;29672:2;29654:21;;;29711:2;29691:18;;;29684:30;29750:34;29745:2;29730:18;;29723:62;-1:-1:-1;;;29816:2:1;29801:18;;29794:40;29866:3;29851:19;;29470:406::o;29881:465::-;30138:2;30127:9;30120:21;30101:4;30164:56;30216:2;30205:9;30201:18;30193:6;30164:56;:::i;:::-;30268:9;30260:6;30256:22;30251:2;30240:9;30236:18;30229:50;30296:44;30333:6;30325;30296:44;:::i;:::-;30288:52;29881:465;-1:-1:-1;;;;;29881:465:1:o;30761:136::-;30800:3;30828:5;30818:39;;30837:18;;:::i;:::-;-1:-1:-1;;;30873:18:1;;30761:136::o;31263:827::-;-1:-1:-1;;;;;31660:15:1;;;31642:34;;31712:15;;31707:2;31692:18;;31685:43;31622:3;31759:2;31744:18;;31737:31;;;31585:4;;31791:57;;31828:19;;31820:6;31791:57;:::i;:::-;31896:9;31888:6;31884:22;31879:2;31868:9;31864:18;31857:50;31930:44;31967:6;31959;31930:44;:::i;:::-;31916:58;;32023:9;32015:6;32011:22;32005:3;31994:9;31990:19;31983:51;32051:33;32077:6;32069;32051:33;:::i;:::-;32043:41;31263:827;-1:-1:-1;;;;;;;;31263:827:1:o

Swarm Source

ipfs://f0e8ffc6fc7cbe41a08da478a9000b22dc6754c9541d4de4dfc9f281b3945339

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

Tools & Services