Token

Pubacoin (PUBA)

ERC-20

Overview

Max Total Supply

1,000,000,000,000 PUBA

Holders

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x3402c289a95d26434f7cfaef99fa0dac6422547e

Filtered by Token Holder

0xd16b6b7B880669EfAbc9C55014fa7198D06ACAF1

Balance

2,257,643 PUBA

Value

$0.00

0xd16b6b7b880669efabc9c55014fa7198d06acaf1

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Pubacoin

Compiler Version

v0.8.17+commit.8df45f5f

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

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

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

// SPDX-License-Identifier: MIT
// 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/token/ERC20/extensions/draft-IERC20Permit.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

   

    

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

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


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

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/utils/math/Math.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

// File: @openzeppelin/contracts/utils/cryptography/ECDSA.sol


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

pragma solidity ^0.8.0;


/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

// File: @openzeppelin/contracts/utils/cryptography/EIP712.sol


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

pragma solidity ^0.8.0;


/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;
    address private immutable _CACHED_THIS;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
        _CACHED_THIS = address(this);
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}

// File: @openzeppelin/contracts/access/IAccessControl.sol


// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}

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


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

pragma solidity ^0.8.0;

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

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

// File: @openzeppelin/contracts/access/AccessControl.sol


// OpenZeppelin Contracts (last updated v4.8.0) (access/AccessControl.sol)

pragma solidity ^0.8.0;





/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

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

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `_msgSender()` is missing `role`.
     * Overriding this function changes the behavior of the {onlyRole} modifier.
     *
     * Format of the revert message is described in {_checkRole}.
     *
     * _Available since v4.6._
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(account),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * May emit a {RoleGranted} event.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

// File: @openzeppelin/contracts/security/Pausable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

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


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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

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


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

pragma solidity ^0.8.0;




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    // Blacklist Map
    mapping(address => bool) public bots;
    

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");
        require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
       

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */


    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }


    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

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

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

// File: @openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/extensions/draft-ERC20Permit.sol)

pragma solidity ^0.8.0;






/**
 * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * _Available since v3.4._
 */
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
    using Counters for Counters.Counter;

    mapping(address => Counters.Counter) private _nonces;

    // solhint-disable-next-line var-name-mixedcase
    bytes32 private constant _PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    /**
     * @dev In previous versions `_PERMIT_TYPEHASH` was declared as `immutable`.
     * However, to ensure consistency with the upgradeable transpiler, we will continue
     * to reserve a slot.
     * @custom:oz-renamed-from _PERMIT_TYPEHASH
     */
    // solhint-disable-next-line var-name-mixedcase
    bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT;

    /**
     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
     *
     * It's a good idea to use the same `name` that is defined as the ERC20 token name.
     */
    constructor(string memory name) EIP712(name, "1") {}

    /**
     * @dev See {IERC20Permit-permit}.
     */


    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual override {
        require(block.timestamp <= deadline, "ERC20Permit: expired deadline");

        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));

        bytes32 hash = _hashTypedDataV4(structHash);

        address signer = ECDSA.recover(hash, v, r, s);
        require(signer == owner, "ERC20Permit: invalid signature");

        _approve(owner, spender, value);
    }

    

    /**
     * @dev See {IERC20Permit-nonces}.
     */
    function nonces(address owner) public view virtual override returns (uint256) {
        return _nonces[owner].current();
    }

    /**
     * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view override returns (bytes32) {
        return _domainSeparatorV4();
    }


    /**
     * @dev "Consume a nonce": return the current value and increment.
     *
     * _Available since v4.1._
     */
    function _useNonce(address owner) internal virtual returns (uint256 current) {
        Counters.Counter storage nonce = _nonces[owner];
        current = nonce.current();
        nonce.increment();
    }
}

// File: @openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol


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

pragma solidity ^0.8.0;



/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        _spendAllowance(account, _msgSender(), amount);
        _burn(account, amount);
    }
}

// File: contracts/BRICSTether.sol


pragma solidity ^0.8.9;


/// @custom:security-contact b [email protected]
contract Pubacoin is ERC20, ERC20Burnable, Pausable, AccessControl, ERC20Permit {
    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");

    constructor() ERC20("Pubacoin", "PUBA") ERC20Permit("Pubacoin") {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(PAUSER_ROLE, msg.sender);
        _mint(msg.sender, 1000000000000 * 10 ** decimals());
        _grantRole(MINTER_ROLE, msg.sender);
    }

    

    function pause() public onlyRole(PAUSER_ROLE) {
        _pause();
    }

    function unpause() public onlyRole(PAUSER_ROLE) {
        _unpause();
    }

    function mint(address to, uint256 amount) public onlyRole(MINTER_ROLE) {
        _mint(to, amount);
    }
    
    function blockBots(address[] memory bots_) public onlyRole(MINTER_ROLE) {
        for (uint256 i = 0; i < bots_.length; i++) {
            bots[bots_[i]] = true;
        }
    }
 
    function unblockBot(address notbot) public onlyRole(MINTER_ROLE) {
        bots[notbot] = false;
    }

    function _beforeTokenTransfer(address from, address to, uint256 amount)
        internal
        whenNotPaused
        override
    {
        super._beforeTokenTransfer(from, to, amount);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAUSER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"bots_","type":"address[]"}],"name":"blockBots","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"bots","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","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":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"notbot","type":"address"}],"name":"unblockBot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","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

70986:1311:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71793:181;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40943:204;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55098:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57449:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56218:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58230:295;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42766:131;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43207:147;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56060:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69231:115;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44351:218;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;58934:238;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71589:77;;;:::i;:::-;;71674:107;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;70283:91;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;48285:86;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71983:104;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56389:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70693:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;68973:128;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71508:73;;;:::i;:::-;;41239:147;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55317:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40344:49;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59675:436;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56722:193;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54454:36;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68254:645;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71142:62;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43647:149;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56978:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71073:62;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71793:181;71180:24;40835:16;40846:4;40835:10;:16::i;:::-;71881:9:::1;71876:91;71900:5;:12;71896:1;:16;71876:91;;;71951:4;71934;:14;71939:5;71945:1;71939:8;;;;;;;;:::i;:::-;;;;;;;;71934:14;;;;;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;71914:3;;;;;:::i;:::-;;;;71876:91;;;;71793:181:::0;;:::o;40943:204::-;41028:4;41067:32;41052:47;;;:11;:47;;;;:87;;;;41103:36;41127:11;41103:23;:36::i;:::-;41052:87;41045:94;;40943:204;;;:::o;55098:100::-;55152:13;55185:5;55178:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55098:100;:::o;57449:201::-;57532:4;57549:13;57565:12;:10;:12::i;:::-;57549:28;;57588:32;57597:5;57604:7;57613:6;57588:8;:32::i;:::-;57638:4;57631:11;;;57449:201;;;;:::o;56218:108::-;56279:7;56306:12;;56299:19;;56218:108;:::o;58230:295::-;58361:4;58378:15;58396:12;:10;:12::i;:::-;58378:30;;58419:38;58435:4;58441:7;58450:6;58419:15;:38::i;:::-;58468:27;58478:4;58484:2;58488:6;58468:9;:27::i;:::-;58513:4;58506:11;;;58230:295;;;;;:::o;42766:131::-;42840:7;42867:6;:12;42874:4;42867:12;;;;;;;;;;;:22;;;42860:29;;42766:131;;;:::o;43207:147::-;43290:18;43303:4;43290:12;:18::i;:::-;40835:16;40846:4;40835:10;:16::i;:::-;43321:25:::1;43332:4;43338:7;43321:10;:25::i;:::-;43207:147:::0;;;:::o;56060:93::-;56118:5;56143:2;56136:9;;56060:93;:::o;69231:115::-;69291:7;69318:20;:18;:20::i;:::-;69311:27;;69231:115;:::o;44351:218::-;44458:12;:10;:12::i;:::-;44447:23;;:7;:23;;;44439:83;;;;;;;;;;;;:::i;:::-;;;;;;;;;44535:26;44547:4;44553:7;44535:11;:26::i;:::-;44351:218;;:::o;58934:238::-;59022:4;59039:13;59055:12;:10;:12::i;:::-;59039:28;;59078:64;59087:5;59094:7;59131:10;59103:25;59113:5;59120:7;59103:9;:25::i;:::-;:38;;;;:::i;:::-;59078:8;:64::i;:::-;59160:4;59153:11;;;58934:238;;;;:::o;71589:77::-;71111:24;40835:16;40846:4;40835:10;:16::i;:::-;71648:10:::1;:8;:10::i;:::-;71589:77:::0;:::o;71674:107::-;71180:24;40835:16;40846:4;40835:10;:16::i;:::-;71756:17:::1;71762:2;71766:6;71756:5;:17::i;:::-;71674:107:::0;;;:::o;70283:91::-;70339:27;70345:12;:10;:12::i;:::-;70359:6;70339:5;:27::i;:::-;70283:91;:::o;48285:86::-;48332:4;48356:7;;;;;;;;;;;48349:14;;48285:86;:::o;71983:104::-;71180:24;40835:16;40846:4;40835:10;:16::i;:::-;72074:5:::1;72059:4;:12;72064:6;72059:12;;;;;;;;;;;;;;;;:20;;;;;;;;;;;;;;;;;;71983:104:::0;;:::o;56389:127::-;56463:7;56490:9;:18;56500:7;56490:18;;;;;;;;;;;;;;;;56483:25;;56389:127;;;:::o;70693:164::-;70770:46;70786:7;70795:12;:10;:12::i;:::-;70809:6;70770:15;:46::i;:::-;70827:22;70833:7;70842:6;70827:5;:22::i;:::-;70693:164;;:::o;68973:128::-;69042:7;69069:24;:7;:14;69077:5;69069:14;;;;;;;;;;;;;;;:22;:24::i;:::-;69062:31;;68973:128;;;:::o;71508:73::-;71111:24;40835:16;40846:4;40835:10;:16::i;:::-;71565:8:::1;:6;:8::i;:::-;71508:73:::0;:::o;41239:147::-;41325:4;41349:6;:12;41356:4;41349:12;;;;;;;;;;;:20;;:29;41370:7;41349:29;;;;;;;;;;;;;;;;;;;;;;;;;41342:36;;41239:147;;;;:::o;55317:104::-;55373:13;55406:7;55399:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55317:104;:::o;40344:49::-;40389:4;40344:49;;;:::o;59675:436::-;59768:4;59785:13;59801:12;:10;:12::i;:::-;59785:28;;59824:24;59851:25;59861:5;59868:7;59851:9;:25::i;:::-;59824:52;;59915:15;59895:16;:35;;59887:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;60008:60;60017:5;60024:7;60052:15;60033:16;:34;60008:8;:60::i;:::-;60099:4;60092:11;;;;59675:436;;;;:::o;56722:193::-;56801:4;56818:13;56834:12;:10;:12::i;:::-;56818:28;;56857;56867:5;56874:2;56878:6;56857:9;:28::i;:::-;56903:4;56896:11;;;56722:193;;;;:::o;54454:36::-;;;;;;;;;;;;;;;;;;;;;;:::o;68254:645::-;68498:8;68479:15;:27;;68471:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;68553:18;67425:95;68613:5;68620:7;68629:5;68636:16;68646:5;68636:9;:16::i;:::-;68654:8;68584:79;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;68574:90;;;;;;68553:111;;68677:12;68692:28;68709:10;68692:16;:28::i;:::-;68677:43;;68733:14;68750:28;68764:4;68770:1;68773;68776;68750:13;:28::i;:::-;68733:45;;68807:5;68797:15;;:6;:15;;;68789:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;68860:31;68869:5;68876:7;68885:5;68860:8;:31::i;:::-;68460:439;;;68254:645;;;;;;;:::o;71142:62::-;71180:24;71142:62;:::o;43647:149::-;43731:18;43744:4;43731:12;:18::i;:::-;40835:16;40846:4;40835:10;:16::i;:::-;43762:26:::1;43774:4;43780:7;43762:11;:26::i;:::-;43647:149:::0;;;:::o;56978:151::-;57067:7;57094:11;:18;57106:5;57094:18;;;;;;;;;;;;;;;:27;57113:7;57094:27;;;;;;;;;;;;;;;;57087:34;;56978:151;;;;:::o;71073:62::-;71111:24;71073:62;:::o;65540:125::-;;;;:::o;41690:105::-;41757:30;41768:4;41774:12;:10;:12::i;:::-;41757:10;:30::i;:::-;41690:105;:::o;5674:157::-;5759:4;5798:25;5783:40;;;:11;:40;;;;5776:47;;5674:157;;;:::o;38152:98::-;38205:7;38232:10;38225:17;;38152:98;:::o;63814:380::-;63967:1;63950:19;;:5;:19;;;63942:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;64048:1;64029:21;;:7;:21;;;64021:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;64132:6;64102:11;:18;64114:5;64102:18;;;;;;;;;;;;;;;:27;64121:7;64102:27;;;;;;;;;;;;;;;:36;;;;64170:7;64154:32;;64163:5;64154:32;;;64179:6;64154:32;;;;;;:::i;:::-;;;;;;;;63814:380;;;:::o;64487:453::-;64622:24;64649:25;64659:5;64666:7;64649:9;:25::i;:::-;64622:52;;64709:17;64689:16;:37;64685:248;;64771:6;64751:16;:26;;64743:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;64855:51;64864:5;64871:7;64899:6;64880:16;:25;64855:8;:51::i;:::-;64685:248;64611:329;64487:453;;;:::o;60581:932::-;60728:1;60712:18;;:4;:18;;;60704:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;60805:1;60791:16;;:2;:16;;;60783:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;60867:4;:10;60872:4;60867:10;;;;;;;;;;;;;;;;;;;;;;;;;60866:11;:24;;;;;60882:4;:8;60887:2;60882:8;;;;;;;;;;;;;;;;;;;;;;;;;60881:9;60866:24;60858:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;60952:38;60973:4;60979:2;60983:6;60952:20;:38::i;:::-;61003:19;61025:9;:15;61035:4;61025:15;;;;;;;;;;;;;;;;61003:37;;61074:6;61059:11;:21;;61051:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;61191:6;61177:11;:20;61159:9;:15;61169:4;61159:15;;;;;;;;;;;;;;;:38;;;;61394:6;61377:9;:13;61387:2;61377:13;;;;;;;;;;;;;;;;:23;;;;;;;;;;;61444:2;61429:26;;61438:4;61429:26;;;61448:6;61429:26;;;;;;:::i;:::-;;;;;;;;61468:37;61488:4;61494:2;61498:6;61468:19;:37::i;:::-;60693:820;60581:932;;;:::o;45948:238::-;46032:22;46040:4;46046:7;46032;:22::i;:::-;46027:152;;46103:4;46071:6;:12;46078:4;46071:12;;;;;;;;;;;:20;;:29;46092:7;46071:29;;;;;;;;;;;;;;;;:36;;;;;;;;;;;;;;;;;;46154:12;:10;:12::i;:::-;46127:40;;46145:7;46127:40;;46139:4;46127:40;;;;;;;;;;46027:152;45948:238;;:::o;33031:314::-;33084:7;33125:12;33108:29;;33116:4;33108:29;;;:66;;;;;33158:16;33141:13;:33;33108:66;33104:234;;;33198:24;33191:31;;;;33104:234;33262:64;33284:10;33296:12;33310:15;33262:21;:64::i;:::-;33255:71;;33031:314;;:::o;46366:239::-;46450:22;46458:4;46464:7;46450;:22::i;:::-;46446:152;;;46521:5;46489:6;:12;46496:4;46489:12;;;;;;;;;;;:20;;:29;46510:7;46489:29;;;;;;;;;;;;;;;;:37;;;;;;;;;;;;;;;;;;46573:12;:10;:12::i;:::-;46546:40;;46564:7;46546:40;;46558:4;46546:40;;;;;;;;;;46446:152;46366:239;;:::o;49140:120::-;48149:16;:14;:16::i;:::-;49209:5:::1;49199:7;;:15;;;;;;;;;;;;;;;;;;49230:22;49239:12;:10;:12::i;:::-;49230:22;;;;;;:::i;:::-;;;;;;;;49140:120::o:0;61812:548::-;61915:1;61896:21;;:7;:21;;;61888:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;61966:49;61995:1;61999:7;62008:6;61966:20;:49::i;:::-;62044:6;62028:12;;:22;;;;;;;:::i;:::-;;;;;;;;62221:6;62199:9;:18;62209:7;62199:18;;;;;;;;;;;;;;;;:28;;;;;;;;;;;62275:7;62254:37;;62271:1;62254:37;;;62284:6;62254:37;;;;;;:::i;:::-;;;;;;;;62304:48;62332:1;62336:7;62345:6;62304:19;:48::i;:::-;61812:548;;:::o;62701:675::-;62804:1;62785:21;;:7;:21;;;62777:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;62857:49;62878:7;62895:1;62899:6;62857:20;:49::i;:::-;62919:22;62944:9;:18;62954:7;62944:18;;;;;;;;;;;;;;;;62919:43;;62999:6;62981:14;:24;;62973:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;63118:6;63101:14;:23;63080:9;:18;63090:7;63080:18;;;;;;;;;;;;;;;:44;;;;63235:6;63219:12;;:22;;;;;;;;;;;63296:1;63270:37;;63279:7;63270:37;;;63300:6;63270:37;;;;;;:::i;:::-;;;;;;;;63320:48;63340:7;63357:1;63361:6;63320:19;:48::i;:::-;62766:610;62701:675;;:::o;919:114::-;984:7;1011;:14;;;1004:21;;919:114;;;:::o;48881:118::-;47890:19;:17;:19::i;:::-;48951:4:::1;48941:7;;:14;;;;;;;;;;;;;;;;;;48971:20;48978:12;:10;:12::i;:::-;48971:20;;;;;;:::i;:::-;;;;;;;;48881:118::o:0;69486:207::-;69546:15;69574:30;69607:7;:14;69615:5;69607:14;;;;;;;;;;;;;;;69574:47;;69642:15;:5;:13;:15::i;:::-;69632:25;;69668:17;:5;:15;:17::i;:::-;69563:130;69486:207;;;:::o;34258:167::-;34335:7;34362:55;34384:20;:18;:20::i;:::-;34406:10;34362:21;:55::i;:::-;34355:62;;34258:167;;;:::o;27904:279::-;28032:7;28053:17;28072:18;28094:25;28105:4;28111:1;28114;28117;28094:10;:25::i;:::-;28052:67;;;;28130:18;28142:5;28130:11;:18::i;:::-;28166:9;28159:16;;;;27904:279;;;;;;:::o;42085:492::-;42174:22;42182:4;42188:7;42174;:22::i;:::-;42169:401;;42362:28;42382:7;42362:19;:28::i;:::-;42463:38;42491:4;42483:13;;42498:2;42463:19;:38::i;:::-;42267:257;;;;;;;;;:::i;:::-;;;;;;;;;;;;;42213:345;;;;;;;;;;;:::i;:::-;;;;;;;;42169:401;42085:492;;:::o;72095:199::-;47890:19;:17;:19::i;:::-;72242:44:::1;72269:4;72275:2;72279:6;72242:26;:44::i;:::-;72095:199:::0;;;:::o;66269:124::-;;;;:::o;33353:263::-;33497:7;33545:8;33555;33565:11;33578:13;33601:4;33534:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;33524:84;;;;;;33517:91;;33353:263;;;;;:::o;48629:108::-;48696:8;:6;:8::i;:::-;48688:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;48629:108::o;48444:::-;48515:8;:6;:8::i;:::-;48514:9;48506:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;48444:108::o;1041:127::-;1148:1;1130:7;:14;;;:19;;;;;;;;;;;1041:127;:::o;29595:196::-;29688:7;29754:15;29771:10;29725:57;;;;;;;;;:::i;:::-;;;;;;;;;;;;;29715:68;;;;;;29708:75;;29595:196;;;;:::o;26245:1520::-;26376:7;26385:12;27310:66;27305:1;27297:10;;:79;27293:163;;;27409:1;27413:30;27393:51;;;;;;27293:163;27553:14;27570:24;27580:4;27586:1;27589;27592;27570:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27553:41;;27627:1;27609:20;;:6;:20;;;27605:103;;27662:1;27666:29;27646:50;;;;;;;27605:103;27728:6;27736:20;27720:37;;;;;26245:1520;;;;;;;;:::o;21637:521::-;21715:20;21706:29;;;;;;;;:::i;:::-;;:5;:29;;;;;;;;:::i;:::-;;;21702:449;21752:7;21702:449;21813:29;21804:38;;;;;;;;:::i;:::-;;:5;:38;;;;;;;;:::i;:::-;;;21800:351;;21859:34;;;;;;;;;;:::i;:::-;;;;;;;;21800:351;21924:35;21915:44;;;;;;;;:::i;:::-;;:5;:44;;;;;;;;:::i;:::-;;;21911:240;;21976:41;;;;;;;;;;:::i;:::-;;;;;;;;21911:240;22048:30;22039:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;22035:116;;22095:44;;;;;;;;;;:::i;:::-;;;;;;;;22035:116;21637:521;;:::o;20879:151::-;20937:13;20970:52;20998:4;20982:22;;19034:2;20970:52;;:11;:52::i;:::-;20963:59;;20879:151;;;:::o;20275:447::-;20350:13;20376:19;20421:1;20412:6;20408:1;:10;;;;:::i;:::-;:14;;;;:::i;:::-;20398:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20376:47;;20434:15;:6;20441:1;20434:9;;;;;;;;:::i;:::-;;;;;:15;;;;;;;;;;;20460;:6;20467:1;20460:9;;;;;;;;:::i;:::-;;;;;:15;;;;;;;;;;;20491:9;20516:1;20507:6;20503:1;:10;;;;:::i;:::-;:14;;;;:::i;:::-;20491:26;;20486:131;20523:1;20519;:5;20486:131;;;20558:8;20575:3;20567:5;:11;20558:21;;;;;;;:::i;:::-;;;;;20546:6;20553:1;20546:9;;;;;;;;:::i;:::-;;;;;:33;;;;;;;;;;;20604:1;20594:11;;;;;20526:3;;;;:::i;:::-;;;20486:131;;;;20644:1;20635:5;:10;20627:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;20707:6;20693:21;;;20275:447;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:117;443:1;440;433:12;457:102;498:6;549:2;545:7;540:2;533:5;529:14;525:28;515:38;;457:102;;;:::o;565:180::-;613:77;610:1;603:88;710:4;707:1;700:15;734:4;731:1;724:15;751:281;834:27;856:4;834:27;:::i;:::-;826:6;822:40;964:6;952:10;949:22;928:18;916:10;913:34;910:62;907:88;;;975:18;;:::i;:::-;907:88;1015:10;1011:2;1004:22;794:238;751:281;;:::o;1038:129::-;1072:6;1099:20;;:::i;:::-;1089:30;;1128:33;1156:4;1148:6;1128:33;:::i;:::-;1038:129;;;:::o;1173:311::-;1250:4;1340:18;1332:6;1329:30;1326:56;;;1362:18;;:::i;:::-;1326:56;1412:4;1404:6;1400:17;1392:25;;1472:4;1466;1462:15;1454:23;;1173:311;;;:::o;1490:117::-;1599:1;1596;1589:12;1613:126;1650:7;1690:42;1683:5;1679:54;1668:65;;1613:126;;;:::o;1745:96::-;1782:7;1811:24;1829:5;1811:24;:::i;:::-;1800:35;;1745:96;;;:::o;1847:122::-;1920:24;1938:5;1920:24;:::i;:::-;1913:5;1910:35;1900:63;;1959:1;1956;1949:12;1900:63;1847:122;:::o;1975:139::-;2021:5;2059:6;2046:20;2037:29;;2075:33;2102:5;2075:33;:::i;:::-;1975:139;;;;:::o;2137:710::-;2233:5;2258:81;2274:64;2331:6;2274:64;:::i;:::-;2258:81;:::i;:::-;2249:90;;2359:5;2388:6;2381:5;2374:21;2422:4;2415:5;2411:16;2404:23;;2475:4;2467:6;2463:17;2455:6;2451:30;2504:3;2496:6;2493:15;2490:122;;;2523:79;;:::i;:::-;2490:122;2638:6;2621:220;2655:6;2650:3;2647:15;2621:220;;;2730:3;2759:37;2792:3;2780:10;2759:37;:::i;:::-;2754:3;2747:50;2826:4;2821:3;2817:14;2810:21;;2697:144;2681:4;2676:3;2672:14;2665:21;;2621:220;;;2625:21;2239:608;;2137:710;;;;;:::o;2870:370::-;2941:5;2990:3;2983:4;2975:6;2971:17;2967:27;2957:122;;2998:79;;:::i;:::-;2957:122;3115:6;3102:20;3140:94;3230:3;3222:6;3215:4;3207:6;3203:17;3140:94;:::i;:::-;3131:103;;2947:293;2870:370;;;;:::o;3246:539::-;3330:6;3379:2;3367:9;3358:7;3354:23;3350:32;3347:119;;;3385:79;;:::i;:::-;3347:119;3533:1;3522:9;3518:17;3505:31;3563:18;3555:6;3552:30;3549:117;;;3585:79;;:::i;:::-;3549:117;3690:78;3760:7;3751:6;3740:9;3736:22;3690:78;:::i;:::-;3680:88;;3476:302;3246:539;;;;:::o;3791:149::-;3827:7;3867:66;3860:5;3856:78;3845:89;;3791:149;;;:::o;3946:120::-;4018:23;4035:5;4018:23;:::i;:::-;4011:5;4008:34;3998:62;;4056:1;4053;4046:12;3998:62;3946:120;:::o;4072:137::-;4117:5;4155:6;4142:20;4133:29;;4171:32;4197:5;4171:32;:::i;:::-;4072:137;;;;:::o;4215:327::-;4273:6;4322:2;4310:9;4301:7;4297:23;4293:32;4290:119;;;4328:79;;:::i;:::-;4290:119;4448:1;4473:52;4517:7;4508:6;4497:9;4493:22;4473:52;:::i;:::-;4463:62;;4419:116;4215:327;;;;:::o;4548:90::-;4582:7;4625:5;4618:13;4611:21;4600:32;;4548:90;;;:::o;4644:109::-;4725:21;4740:5;4725:21;:::i;:::-;4720:3;4713:34;4644:109;;:::o;4759:210::-;4846:4;4884:2;4873:9;4869:18;4861:26;;4897:65;4959:1;4948:9;4944:17;4935:6;4897:65;:::i;:::-;4759:210;;;;:::o;4975:99::-;5027:6;5061:5;5055:12;5045:22;;4975:99;;;:::o;5080:169::-;5164:11;5198:6;5193:3;5186:19;5238:4;5233:3;5229:14;5214:29;;5080:169;;;;:::o;5255:246::-;5336:1;5346:113;5360:6;5357:1;5354:13;5346:113;;;5445:1;5440:3;5436:11;5430:18;5426:1;5421:3;5417:11;5410:39;5382:2;5379:1;5375:10;5370:15;;5346:113;;;5493:1;5484:6;5479:3;5475:16;5468:27;5317:184;5255:246;;;:::o;5507:377::-;5595:3;5623:39;5656:5;5623:39;:::i;:::-;5678:71;5742:6;5737:3;5678:71;:::i;:::-;5671:78;;5758:65;5816:6;5811:3;5804:4;5797:5;5793:16;5758:65;:::i;:::-;5848:29;5870:6;5848:29;:::i;:::-;5843:3;5839:39;5832:46;;5599:285;5507:377;;;;:::o;5890:313::-;6003:4;6041:2;6030:9;6026:18;6018:26;;6090:9;6084:4;6080:20;6076:1;6065:9;6061:17;6054:47;6118:78;6191:4;6182:6;6118:78;:::i;:::-;6110:86;;5890:313;;;;:::o;6209:77::-;6246:7;6275:5;6264:16;;6209:77;;;:::o;6292:122::-;6365:24;6383:5;6365:24;:::i;:::-;6358:5;6355:35;6345:63;;6404:1;6401;6394:12;6345:63;6292:122;:::o;6420:139::-;6466:5;6504:6;6491:20;6482:29;;6520:33;6547:5;6520:33;:::i;:::-;6420:139;;;;:::o;6565:474::-;6633:6;6641;6690:2;6678:9;6669:7;6665:23;6661:32;6658:119;;;6696:79;;:::i;:::-;6658:119;6816:1;6841:53;6886:7;6877:6;6866:9;6862:22;6841:53;:::i;:::-;6831:63;;6787:117;6943:2;6969:53;7014:7;7005:6;6994:9;6990:22;6969:53;:::i;:::-;6959:63;;6914:118;6565:474;;;;;:::o;7045:118::-;7132:24;7150:5;7132:24;:::i;:::-;7127:3;7120:37;7045:118;;:::o;7169:222::-;7262:4;7300:2;7289:9;7285:18;7277:26;;7313:71;7381:1;7370:9;7366:17;7357:6;7313:71;:::i;:::-;7169:222;;;;:::o;7397:619::-;7474:6;7482;7490;7539:2;7527:9;7518:7;7514:23;7510:32;7507:119;;;7545:79;;:::i;:::-;7507:119;7665:1;7690:53;7735:7;7726:6;7715:9;7711:22;7690:53;:::i;:::-;7680:63;;7636:117;7792:2;7818:53;7863:7;7854:6;7843:9;7839:22;7818:53;:::i;:::-;7808:63;;7763:118;7920:2;7946:53;7991:7;7982:6;7971:9;7967:22;7946:53;:::i;:::-;7936:63;;7891:118;7397:619;;;;;:::o;8022:77::-;8059:7;8088:5;8077:16;;8022:77;;;:::o;8105:122::-;8178:24;8196:5;8178:24;:::i;:::-;8171:5;8168:35;8158:63;;8217:1;8214;8207:12;8158:63;8105:122;:::o;8233:139::-;8279:5;8317:6;8304:20;8295:29;;8333:33;8360:5;8333:33;:::i;:::-;8233:139;;;;:::o;8378:329::-;8437:6;8486:2;8474:9;8465:7;8461:23;8457:32;8454:119;;;8492:79;;:::i;:::-;8454:119;8612:1;8637:53;8682:7;8673:6;8662:9;8658:22;8637:53;:::i;:::-;8627:63;;8583:117;8378:329;;;;:::o;8713:118::-;8800:24;8818:5;8800:24;:::i;:::-;8795:3;8788:37;8713:118;;:::o;8837:222::-;8930:4;8968:2;8957:9;8953:18;8945:26;;8981:71;9049:1;9038:9;9034:17;9025:6;8981:71;:::i;:::-;8837:222;;;;:::o;9065:474::-;9133:6;9141;9190:2;9178:9;9169:7;9165:23;9161:32;9158:119;;;9196:79;;:::i;:::-;9158:119;9316:1;9341:53;9386:7;9377:6;9366:9;9362:22;9341:53;:::i;:::-;9331:63;;9287:117;9443:2;9469:53;9514:7;9505:6;9494:9;9490:22;9469:53;:::i;:::-;9459:63;;9414:118;9065:474;;;;;:::o;9545:86::-;9580:7;9620:4;9613:5;9609:16;9598:27;;9545:86;;;:::o;9637:112::-;9720:22;9736:5;9720:22;:::i;:::-;9715:3;9708:35;9637:112;;:::o;9755:214::-;9844:4;9882:2;9871:9;9867:18;9859:26;;9895:67;9959:1;9948:9;9944:17;9935:6;9895:67;:::i;:::-;9755:214;;;;:::o;9975:329::-;10034:6;10083:2;10071:9;10062:7;10058:23;10054:32;10051:119;;;10089:79;;:::i;:::-;10051:119;10209:1;10234:53;10279:7;10270:6;10259:9;10255:22;10234:53;:::i;:::-;10224:63;;10180:117;9975:329;;;;:::o;10310:::-;10369:6;10418:2;10406:9;10397:7;10393:23;10389:32;10386:119;;;10424:79;;:::i;:::-;10386:119;10544:1;10569:53;10614:7;10605:6;10594:9;10590:22;10569:53;:::i;:::-;10559:63;;10515:117;10310:329;;;;:::o;10645:118::-;10716:22;10732:5;10716:22;:::i;:::-;10709:5;10706:33;10696:61;;10753:1;10750;10743:12;10696:61;10645:118;:::o;10769:135::-;10813:5;10851:6;10838:20;10829:29;;10867:31;10892:5;10867:31;:::i;:::-;10769:135;;;;:::o;10910:1199::-;11021:6;11029;11037;11045;11053;11061;11069;11118:3;11106:9;11097:7;11093:23;11089:33;11086:120;;;11125:79;;:::i;:::-;11086:120;11245:1;11270:53;11315:7;11306:6;11295:9;11291:22;11270:53;:::i;:::-;11260:63;;11216:117;11372:2;11398:53;11443:7;11434:6;11423:9;11419:22;11398:53;:::i;:::-;11388:63;;11343:118;11500:2;11526:53;11571:7;11562:6;11551:9;11547:22;11526:53;:::i;:::-;11516:63;;11471:118;11628:2;11654:53;11699:7;11690:6;11679:9;11675:22;11654:53;:::i;:::-;11644:63;;11599:118;11756:3;11783:51;11826:7;11817:6;11806:9;11802:22;11783:51;:::i;:::-;11773:61;;11727:117;11883:3;11910:53;11955:7;11946:6;11935:9;11931:22;11910:53;:::i;:::-;11900:63;;11854:119;12012:3;12039:53;12084:7;12075:6;12064:9;12060:22;12039:53;:::i;:::-;12029:63;;11983:119;10910:1199;;;;;;;;;;:::o;12115:474::-;12183:6;12191;12240:2;12228:9;12219:7;12215:23;12211:32;12208:119;;;12246:79;;:::i;:::-;12208:119;12366:1;12391:53;12436:7;12427:6;12416:9;12412:22;12391:53;:::i;:::-;12381:63;;12337:117;12493:2;12519:53;12564:7;12555:6;12544:9;12540:22;12519:53;:::i;:::-;12509:63;;12464:118;12115:474;;;;;:::o;12595:180::-;12643:77;12640:1;12633:88;12740:4;12737:1;12730:15;12764:4;12761:1;12754:15;12781:180;12829:77;12826:1;12819:88;12926:4;12923:1;12916:15;12950:4;12947:1;12940:15;12967:233;13006:3;13029:24;13047:5;13029:24;:::i;:::-;13020:33;;13075:66;13068:5;13065:77;13062:103;;13145:18;;:::i;:::-;13062:103;13192:1;13185:5;13181:13;13174:20;;12967:233;;;:::o;13206:180::-;13254:77;13251:1;13244:88;13351:4;13348:1;13341:15;13375:4;13372:1;13365:15;13392:320;13436:6;13473:1;13467:4;13463:12;13453:22;;13520:1;13514:4;13510:12;13541:18;13531:81;;13597:4;13589:6;13585:17;13575:27;;13531:81;13659:2;13651:6;13648:14;13628:18;13625:38;13622:84;;13678:18;;:::i;:::-;13622:84;13443:269;13392:320;;;:::o;13718:234::-;13858:34;13854:1;13846:6;13842:14;13835:58;13927:17;13922:2;13914:6;13910:15;13903:42;13718:234;:::o;13958:366::-;14100:3;14121:67;14185:2;14180:3;14121:67;:::i;:::-;14114:74;;14197:93;14286:3;14197:93;:::i;:::-;14315:2;14310:3;14306:12;14299:19;;13958:366;;;:::o;14330:419::-;14496:4;14534:2;14523:9;14519:18;14511:26;;14583:9;14577:4;14573:20;14569:1;14558:9;14554:17;14547:47;14611:131;14737:4;14611:131;:::i;:::-;14603:139;;14330:419;;;:::o;14755:191::-;14795:3;14814:20;14832:1;14814:20;:::i;:::-;14809:25;;14848:20;14866:1;14848:20;:::i;:::-;14843:25;;14891:1;14888;14884:9;14877:16;;14912:3;14909:1;14906:10;14903:36;;;14919:18;;:::i;:::-;14903:36;14755:191;;;;:::o;14952:224::-;15092:34;15088:1;15080:6;15076:14;15069:58;15161:7;15156:2;15148:6;15144:15;15137:32;14952:224;:::o;15182:366::-;15324:3;15345:67;15409:2;15404:3;15345:67;:::i;:::-;15338:74;;15421:93;15510:3;15421:93;:::i;:::-;15539:2;15534:3;15530:12;15523:19;;15182:366;;;:::o;15554:419::-;15720:4;15758:2;15747:9;15743:18;15735:26;;15807:9;15801:4;15797:20;15793:1;15782:9;15778:17;15771:47;15835:131;15961:4;15835:131;:::i;:::-;15827:139;;15554:419;;;:::o;15979:179::-;16119:31;16115:1;16107:6;16103:14;16096:55;15979:179;:::o;16164:366::-;16306:3;16327:67;16391:2;16386:3;16327:67;:::i;:::-;16320:74;;16403:93;16492:3;16403:93;:::i;:::-;16521:2;16516:3;16512:12;16505:19;;16164:366;;;:::o;16536:419::-;16702:4;16740:2;16729:9;16725:18;16717:26;;16789:9;16783:4;16779:20;16775:1;16764:9;16760:17;16753:47;16817:131;16943:4;16817:131;:::i;:::-;16809:139;;16536:419;;;:::o;16961:118::-;17048:24;17066:5;17048:24;:::i;:::-;17043:3;17036:37;16961:118;;:::o;17085:775::-;17318:4;17356:3;17345:9;17341:19;17333:27;;17370:71;17438:1;17427:9;17423:17;17414:6;17370:71;:::i;:::-;17451:72;17519:2;17508:9;17504:18;17495:6;17451:72;:::i;:::-;17533;17601:2;17590:9;17586:18;17577:6;17533:72;:::i;:::-;17615;17683:2;17672:9;17668:18;17659:6;17615:72;:::i;:::-;17697:73;17765:3;17754:9;17750:19;17741:6;17697:73;:::i;:::-;17780;17848:3;17837:9;17833:19;17824:6;17780:73;:::i;:::-;17085:775;;;;;;;;;:::o;17866:180::-;18006:32;18002:1;17994:6;17990:14;17983:56;17866:180;:::o;18052:366::-;18194:3;18215:67;18279:2;18274:3;18215:67;:::i;:::-;18208:74;;18291:93;18380:3;18291:93;:::i;:::-;18409:2;18404:3;18400:12;18393:19;;18052:366;;;:::o;18424:419::-;18590:4;18628:2;18617:9;18613:18;18605:26;;18677:9;18671:4;18667:20;18663:1;18652:9;18648:17;18641:47;18705:131;18831:4;18705:131;:::i;:::-;18697:139;;18424:419;;;:::o;18849:223::-;18989:34;18985:1;18977:6;18973:14;18966:58;19058:6;19053:2;19045:6;19041:15;19034:31;18849:223;:::o;19078:366::-;19220:3;19241:67;19305:2;19300:3;19241:67;:::i;:::-;19234:74;;19317:93;19406:3;19317:93;:::i;:::-;19435:2;19430:3;19426:12;19419:19;;19078:366;;;:::o;19450:419::-;19616:4;19654:2;19643:9;19639:18;19631:26;;19703:9;19697:4;19693:20;19689:1;19678:9;19674:17;19667:47;19731:131;19857:4;19731:131;:::i;:::-;19723:139;;19450:419;;;:::o;19875:221::-;20015:34;20011:1;20003:6;19999:14;19992:58;20084:4;20079:2;20071:6;20067:15;20060:29;19875:221;:::o;20102:366::-;20244:3;20265:67;20329:2;20324:3;20265:67;:::i;:::-;20258:74;;20341:93;20430:3;20341:93;:::i;:::-;20459:2;20454:3;20450:12;20443:19;;20102:366;;;:::o;20474:419::-;20640:4;20678:2;20667:9;20663:18;20655:26;;20727:9;20721:4;20717:20;20713:1;20702:9;20698:17;20691:47;20755:131;20881:4;20755:131;:::i;:::-;20747:139;;20474:419;;;:::o;20899:179::-;21039:31;21035:1;21027:6;21023:14;21016:55;20899:179;:::o;21084:366::-;21226:3;21247:67;21311:2;21306:3;21247:67;:::i;:::-;21240:74;;21323:93;21412:3;21323:93;:::i;:::-;21441:2;21436:3;21432:12;21425:19;;21084:366;;;:::o;21456:419::-;21622:4;21660:2;21649:9;21645:18;21637:26;;21709:9;21703:4;21699:20;21695:1;21684:9;21680:17;21673:47;21737:131;21863:4;21737:131;:::i;:::-;21729:139;;21456:419;;;:::o;21881:224::-;22021:34;22017:1;22009:6;22005:14;21998:58;22090:7;22085:2;22077:6;22073:15;22066:32;21881:224;:::o;22111:366::-;22253:3;22274:67;22338:2;22333:3;22274:67;:::i;:::-;22267:74;;22350:93;22439:3;22350:93;:::i;:::-;22468:2;22463:3;22459:12;22452:19;;22111:366;;;:::o;22483:419::-;22649:4;22687:2;22676:9;22672:18;22664:26;;22736:9;22730:4;22726:20;22722:1;22711:9;22707:17;22700:47;22764:131;22890:4;22764:131;:::i;:::-;22756:139;;22483:419;;;:::o;22908:222::-;23048:34;23044:1;23036:6;23032:14;23025:58;23117:5;23112:2;23104:6;23100:15;23093:30;22908:222;:::o;23136:366::-;23278:3;23299:67;23363:2;23358:3;23299:67;:::i;:::-;23292:74;;23375:93;23464:3;23375:93;:::i;:::-;23493:2;23488:3;23484:12;23477:19;;23136:366;;;:::o;23508:419::-;23674:4;23712:2;23701:9;23697:18;23689:26;;23761:9;23755:4;23751:20;23747:1;23736:9;23732:17;23725:47;23789:131;23915:4;23789:131;:::i;:::-;23781:139;;23508:419;;;:::o;23933:222::-;24073:34;24069:1;24061:6;24057:14;24050:58;24142:5;24137:2;24129:6;24125:15;24118:30;23933:222;:::o;24161:366::-;24303:3;24324:67;24388:2;24383:3;24324:67;:::i;:::-;24317:74;;24400:93;24489:3;24400:93;:::i;:::-;24518:2;24513:3;24509:12;24502:19;;24161:366;;;:::o;24533:419::-;24699:4;24737:2;24726:9;24722:18;24714:26;;24786:9;24780:4;24776:20;24772:1;24761:9;24757:17;24750:47;24814:131;24940:4;24814:131;:::i;:::-;24806:139;;24533:419;;;:::o;24958:225::-;25098:34;25094:1;25086:6;25082:14;25075:58;25167:8;25162:2;25154:6;25150:15;25143:33;24958:225;:::o;25189:366::-;25331:3;25352:67;25416:2;25411:3;25352:67;:::i;:::-;25345:74;;25428:93;25517:3;25428:93;:::i;:::-;25546:2;25541:3;25537:12;25530:19;;25189:366;;;:::o;25561:419::-;25727:4;25765:2;25754:9;25750:18;25742:26;;25814:9;25808:4;25804:20;25800:1;25789:9;25785:17;25778:47;25842:131;25968:4;25842:131;:::i;:::-;25834:139;;25561:419;;;:::o;25986:222::-;26079:4;26117:2;26106:9;26102:18;26094:26;;26130:71;26198:1;26187:9;26183:17;26174:6;26130:71;:::i;:::-;25986:222;;;;:::o;26214:181::-;26354:33;26350:1;26342:6;26338:14;26331:57;26214:181;:::o;26401:366::-;26543:3;26564:67;26628:2;26623:3;26564:67;:::i;:::-;26557:74;;26640:93;26729:3;26640:93;:::i;:::-;26758:2;26753:3;26749:12;26742:19;;26401:366;;;:::o;26773:419::-;26939:4;26977:2;26966:9;26962:18;26954:26;;27026:9;27020:4;27016:20;27012:1;27001:9;26997:17;26990:47;27054:131;27180:4;27054:131;:::i;:::-;27046:139;;26773:419;;;:::o;27198:220::-;27338:34;27334:1;27326:6;27322:14;27315:58;27407:3;27402:2;27394:6;27390:15;27383:28;27198:220;:::o;27424:366::-;27566:3;27587:67;27651:2;27646:3;27587:67;:::i;:::-;27580:74;;27663:93;27752:3;27663:93;:::i;:::-;27781:2;27776:3;27772:12;27765:19;;27424:366;;;:::o;27796:419::-;27962:4;28000:2;27989:9;27985:18;27977:26;;28049:9;28043:4;28039:20;28035:1;28024:9;28020:17;28013:47;28077:131;28203:4;28077:131;:::i;:::-;28069:139;;27796:419;;;:::o;28221:221::-;28361:34;28357:1;28349:6;28345:14;28338:58;28430:4;28425:2;28417:6;28413:15;28406:29;28221:221;:::o;28448:366::-;28590:3;28611:67;28675:2;28670:3;28611:67;:::i;:::-;28604:74;;28687:93;28776:3;28687:93;:::i;:::-;28805:2;28800:3;28796:12;28789:19;;28448:366;;;:::o;28820:419::-;28986:4;29024:2;29013:9;29009:18;29001:26;;29073:9;29067:4;29063:20;29059:1;29048:9;29044:17;29037:47;29101:131;29227:4;29101:131;:::i;:::-;29093:139;;28820:419;;;:::o;29245:148::-;29347:11;29384:3;29369:18;;29245:148;;;;:::o;29399:173::-;29539:25;29535:1;29527:6;29523:14;29516:49;29399:173;:::o;29578:402::-;29738:3;29759:85;29841:2;29836:3;29759:85;:::i;:::-;29752:92;;29853:93;29942:3;29853:93;:::i;:::-;29971:2;29966:3;29962:12;29955:19;;29578:402;;;:::o;29986:390::-;30092:3;30120:39;30153:5;30120:39;:::i;:::-;30175:89;30257:6;30252:3;30175:89;:::i;:::-;30168:96;;30273:65;30331:6;30326:3;30319:4;30312:5;30308:16;30273:65;:::i;:::-;30363:6;30358:3;30354:16;30347:23;;30096:280;29986:390;;;;:::o;30382:167::-;30522:19;30518:1;30510:6;30506:14;30499:43;30382:167;:::o;30555:402::-;30715:3;30736:85;30818:2;30813:3;30736:85;:::i;:::-;30729:92;;30830:93;30919:3;30830:93;:::i;:::-;30948:2;30943:3;30939:12;30932:19;;30555:402;;;:::o;30963:967::-;31345:3;31367:148;31511:3;31367:148;:::i;:::-;31360:155;;31532:95;31623:3;31614:6;31532:95;:::i;:::-;31525:102;;31644:148;31788:3;31644:148;:::i;:::-;31637:155;;31809:95;31900:3;31891:6;31809:95;:::i;:::-;31802:102;;31921:3;31914:10;;30963:967;;;;;:::o;31936:664::-;32141:4;32179:3;32168:9;32164:19;32156:27;;32193:71;32261:1;32250:9;32246:17;32237:6;32193:71;:::i;:::-;32274:72;32342:2;32331:9;32327:18;32318:6;32274:72;:::i;:::-;32356;32424:2;32413:9;32409:18;32400:6;32356:72;:::i;:::-;32438;32506:2;32495:9;32491:18;32482:6;32438:72;:::i;:::-;32520:73;32588:3;32577:9;32573:19;32564:6;32520:73;:::i;:::-;31936:664;;;;;;;;:::o;32606:170::-;32746:22;32742:1;32734:6;32730:14;32723:46;32606:170;:::o;32782:366::-;32924:3;32945:67;33009:2;33004:3;32945:67;:::i;:::-;32938:74;;33021:93;33110:3;33021:93;:::i;:::-;33139:2;33134:3;33130:12;33123:19;;32782:366;;;:::o;33154:419::-;33320:4;33358:2;33347:9;33343:18;33335:26;;33407:9;33401:4;33397:20;33393:1;33382:9;33378:17;33371:47;33435:131;33561:4;33435:131;:::i;:::-;33427:139;;33154:419;;;:::o;33579:166::-;33719:18;33715:1;33707:6;33703:14;33696:42;33579:166;:::o;33751:366::-;33893:3;33914:67;33978:2;33973:3;33914:67;:::i;:::-;33907:74;;33990:93;34079:3;33990:93;:::i;:::-;34108:2;34103:3;34099:12;34092:19;;33751:366;;;:::o;34123:419::-;34289:4;34327:2;34316:9;34312:18;34304:26;;34376:9;34370:4;34366:20;34362:1;34351:9;34347:17;34340:47;34404:131;34530:4;34404:131;:::i;:::-;34396:139;;34123:419;;;:::o;34548:214::-;34688:66;34684:1;34676:6;34672:14;34665:90;34548:214;:::o;34768:400::-;34928:3;34949:84;35031:1;35026:3;34949:84;:::i;:::-;34942:91;;35042:93;35131:3;35042:93;:::i;:::-;35160:1;35155:3;35151:11;35144:18;;34768:400;;;:::o;35174:79::-;35213:7;35242:5;35231:16;;35174:79;;;:::o;35259:157::-;35364:45;35384:24;35402:5;35384:24;:::i;:::-;35364:45;:::i;:::-;35359:3;35352:58;35259:157;;:::o;35422:663::-;35663:3;35685:148;35829:3;35685:148;:::i;:::-;35678:155;;35843:75;35914:3;35905:6;35843:75;:::i;:::-;35943:2;35938:3;35934:12;35927:19;;35956:75;36027:3;36018:6;35956:75;:::i;:::-;36056:2;36051:3;36047:12;36040:19;;36076:3;36069:10;;35422:663;;;;;:::o;36091:545::-;36264:4;36302:3;36291:9;36287:19;36279:27;;36316:71;36384:1;36373:9;36369:17;36360:6;36316:71;:::i;:::-;36397:68;36461:2;36450:9;36446:18;36437:6;36397:68;:::i;:::-;36475:72;36543:2;36532:9;36528:18;36519:6;36475:72;:::i;:::-;36557;36625:2;36614:9;36610:18;36601:6;36557:72;:::i;:::-;36091:545;;;;;;;:::o;36642:180::-;36690:77;36687:1;36680:88;36787:4;36784:1;36777:15;36811:4;36808:1;36801:15;36828:174;36968:26;36964:1;36956:6;36952:14;36945:50;36828:174;:::o;37008:366::-;37150:3;37171:67;37235:2;37230:3;37171:67;:::i;:::-;37164:74;;37247:93;37336:3;37247:93;:::i;:::-;37365:2;37360:3;37356:12;37349:19;;37008:366;;;:::o;37380:419::-;37546:4;37584:2;37573:9;37569:18;37561:26;;37633:9;37627:4;37623:20;37619:1;37608:9;37604:17;37597:47;37661:131;37787:4;37661:131;:::i;:::-;37653:139;;37380:419;;;:::o;37805:181::-;37945:33;37941:1;37933:6;37929:14;37922:57;37805:181;:::o;37992:366::-;38134:3;38155:67;38219:2;38214:3;38155:67;:::i;:::-;38148:74;;38231:93;38320:3;38231:93;:::i;:::-;38349:2;38344:3;38340:12;38333:19;;37992:366;;;:::o;38364:419::-;38530:4;38568:2;38557:9;38553:18;38545:26;;38617:9;38611:4;38607:20;38603:1;38592:9;38588:17;38581:47;38645:131;38771:4;38645:131;:::i;:::-;38637:139;;38364:419;;;:::o;38789:221::-;38929:34;38925:1;38917:6;38913:14;38906:58;38998:4;38993:2;38985:6;38981:15;38974:29;38789:221;:::o;39016:366::-;39158:3;39179:67;39243:2;39238:3;39179:67;:::i;:::-;39172:74;;39255:93;39344:3;39255:93;:::i;:::-;39373:2;39368:3;39364:12;39357:19;;39016:366;;;:::o;39388:419::-;39554:4;39592:2;39581:9;39577:18;39569:26;;39641:9;39635:4;39631:20;39627:1;39616:9;39612:17;39605:47;39669:131;39795:4;39669:131;:::i;:::-;39661:139;;39388:419;;;:::o;39813:410::-;39853:7;39876:20;39894:1;39876:20;:::i;:::-;39871:25;;39910:20;39928:1;39910:20;:::i;:::-;39905:25;;39965:1;39962;39958:9;39987:30;40005:11;39987:30;:::i;:::-;39976:41;;40166:1;40157:7;40153:15;40150:1;40147:22;40127:1;40120:9;40100:83;40077:139;;40196:18;;:::i;:::-;40077:139;39861:362;39813:410;;;;:::o;40229:171::-;40268:3;40291:24;40309:5;40291:24;:::i;:::-;40282:33;;40337:4;40330:5;40327:15;40324:41;;40345:18;;:::i;:::-;40324:41;40392:1;40385:5;40381:13;40374:20;;40229:171;;;:::o;40406:182::-;40546:34;40542:1;40534:6;40530:14;40523:58;40406:182;:::o;40594:366::-;40736:3;40757:67;40821:2;40816:3;40757:67;:::i;:::-;40750:74;;40833:93;40922:3;40833:93;:::i;:::-;40951:2;40946:3;40942:12;40935:19;;40594:366;;;:::o;40966:419::-;41132:4;41170:2;41159:9;41155:18;41147:26;;41219:9;41213:4;41209:20;41205:1;41194:9;41190:17;41183:47;41247:131;41373:4;41247:131;:::i;:::-;41239:139;;40966:419;;;:::o

Swarm Source

ipfs://9ae55a789168816afcba0c5aa42e0f9b7b1fa44e469e359353304797a979e8d8

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