Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

library Counters    - function current(Counter storage coun ...    - function increment(Counter storage co ...    - function decrement(Counter storage co ...    - function reset(Counter storage counte ... library Math    - function max(uint256 a, uint256 b)    - function min(uint256 a, uint256 b)    - function average(uint256 a, uint256 b ...    - function ceilDiv(uint256 a, uint256 b ...    - function mulDiv(    - function mulDiv(    - function sqrt(uint256 a)    - function sqrt(uint256 a, Rounding rou ...    - function log2(uint256 value)    - function log2(uint256 value, Rounding ...    - function log10(uint256 value)    - function log10(uint256 value, Roundin ...    - function log256(uint256 value)    - function log256(uint256 value, Roundi ... library StorageSlot    - function getAddressSlot(bytes32 slot)    - function getBooleanSlot(bytes32 slot)    - function getBytes32Slot(bytes32 slot)    - function getUint256Slot(bytes32 slot) library Arrays    - function findUpperBound(uint256[] sto ...    - function unsafeAccess(address[] stora ...    - function unsafeAccess(bytes32[] stora ...    - function unsafeAccess(uint256[] stora ...    - function _msgSender()    - function _msgData()    - function owner()    - function _checkOwner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _transferOwnership(address n ...    - function paused()    - function _requireNotPaused()    - function _requirePaused()    - function _pause()    - function _unpause() interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address to, uint256 ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom( interface IERC20Metadata is IERC20    - function name()    - function symbol()    - function decimals()  contract ERC20 is Context, IERC20, ...    - function name()    - function symbol()    - function decimals()    - function totalSupply()    - function balanceOf(address account)    - function transfer(address to, uint256 ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(    - function increaseAllowance(address sp ...    - function decreaseAllowance(address sp ...    - function _transfer(    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _approve(    - function _spendAllowance(    - function _beforeTokenTransfer(    - function _afterTokenTransfer(    - function _beforeTokenTransfer(    - function _snapshot()    - function _getCurrentSnapshotId()    - function balanceOfAt(address account, ...    - function totalSupplyAt(uint256 snapsh ...    - function _beforeTokenTransfer(    - function _valueAt(uint256 snapshotId, ...    - function _updateAccountSnapshot(addre ...    - function _updateTotalSupplySnapshot()    - function _updateSnapshot(Snapshots st ...    - function _lastSnapshotId(uint256[] st ...  contract FBXToken is ERC20Snapshot ... *    - function snapshot()    - function pause()    - function unpause()    - function _beforeTokenTransfer(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

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


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

pragma solidity ^0.8.0;

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

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

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

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

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

// File: @openzeppelin/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/StorageSlot.sol


// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)

pragma solidity ^0.8.0;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }
}

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


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

pragma solidity ^0.8.0;



/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
    using StorageSlot for bytes32;

    /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * `array` is expected to be sorted in ascending order, and to contain no
     * repeated elements.
     */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        if (array.length == 0) {
            return 0;
        }

        uint256 low = 0;
        uint256 high = array.length;

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds down (it does integer division with truncation).
            if (unsafeAccess(array, mid).value > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && unsafeAccess(array, low - 1).value == element) {
            return low - 1;
        } else {
            return low;
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(address[] storage arr, uint256 pos) internal pure returns (StorageSlot.AddressSlot storage) {
        bytes32 slot;
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getAddressSlot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(bytes32[] storage arr, uint256 pos) internal pure returns (StorageSlot.Bytes32Slot storage) {
        bytes32 slot;
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getBytes32Slot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(uint256[] storage arr, uint256 pos) internal pure returns (StorageSlot.Uint256Slot storage) {
        bytes32 slot;
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getUint256Slot();
    }
}

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


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

pragma solidity ^0.8.0;

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/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;

    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");

        _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/ERC20Pausable.sol


// OpenZeppelin Contracts (last updated v4.8.2) (token/ERC20/extensions/ERC20Pausable.sol)

pragma solidity ^0.8.0;



/**
 * @dev ERC20 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 *
 * IMPORTANT: This contract does not include public pause and unpause functions. In
 * addition to inheriting this contract, you must define both functions, invoking the
 * {Pausable-_pause} and {Pausable-_unpause} internal functions, with appropriate
 * access control, e.g. using {AccessControl} or {Ownable}. Not doing so will
 * make the contract unpausable.
 */
abstract contract ERC20Pausable is ERC20, Pausable {
    /**
     * @dev See {ERC20-_beforeTokenTransfer}.
     *
     * Requirements:
     *
     * - the contract must not be paused.
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, amount);

        require(!paused(), "ERC20Pausable: token transfer while paused");
    }
}

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


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/extensions/ERC20Snapshot.sol)

pragma solidity ^0.8.0;




/**
 * @dev This contract extends an ERC20 token with a snapshot mechanism. When a snapshot is created, the balances and
 * total supply at the time are recorded for later access.
 *
 * This can be used to safely create mechanisms based on token balances such as trustless dividends or weighted voting.
 * In naive implementations it's possible to perform a "double spend" attack by reusing the same balance from different
 * accounts. By using snapshots to calculate dividends or voting power, those attacks no longer apply. It can also be
 * used to create an efficient ERC20 forking mechanism.
 *
 * Snapshots are created by the internal {_snapshot} function, which will emit the {Snapshot} event and return a
 * snapshot id. To get the total supply at the time of a snapshot, call the function {totalSupplyAt} with the snapshot
 * id. To get the balance of an account at the time of a snapshot, call the {balanceOfAt} function with the snapshot id
 * and the account address.
 *
 * NOTE: Snapshot policy can be customized by overriding the {_getCurrentSnapshotId} method. For example, having it
 * return `block.number` will trigger the creation of snapshot at the beginning of each new block. When overriding this
 * function, be careful about the monotonicity of its result. Non-monotonic snapshot ids will break the contract.
 *
 * Implementing snapshots for every block using this method will incur significant gas costs. For a gas-efficient
 * alternative consider {ERC20Votes}.
 *
 * ==== Gas Costs
 *
 * Snapshots are efficient. Snapshot creation is _O(1)_. Retrieval of balances or total supply from a snapshot is _O(log
 * n)_ in the number of snapshots that have been created, although _n_ for a specific account will generally be much
 * smaller since identical balances in subsequent snapshots are stored as a single entry.
 *
 * There is a constant overhead for normal ERC20 transfers due to the additional snapshot bookkeeping. This overhead is
 * only significant for the first transfer that immediately follows a snapshot for a particular account. Subsequent
 * transfers will have normal cost until the next snapshot, and so on.
 */

abstract contract ERC20Snapshot is ERC20 {
    // Inspired by Jordi Baylina's MiniMeToken to record historical balances:
    // https://github.com/Giveth/minime/blob/ea04d950eea153a04c51fa510b068b9dded390cb/contracts/MiniMeToken.sol

    using Arrays for uint256[];
    using Counters for Counters.Counter;

    // Snapshotted values have arrays of ids and the value corresponding to that id. These could be an array of a
    // Snapshot struct, but that would impede usage of functions that work on an array.
    struct Snapshots {
        uint256[] ids;
        uint256[] values;
    }

    mapping(address => Snapshots) private _accountBalanceSnapshots;
    Snapshots private _totalSupplySnapshots;

    // Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid.
    Counters.Counter private _currentSnapshotId;

    /**
     * @dev Emitted by {_snapshot} when a snapshot identified by `id` is created.
     */
    event Snapshot(uint256 id);

    /**
     * @dev Creates a new snapshot and returns its snapshot id.
     *
     * Emits a {Snapshot} event that contains the same id.
     *
     * {_snapshot} is `internal` and you have to decide how to expose it externally. Its usage may be restricted to a
     * set of accounts, for example using {AccessControl}, or it may be open to the public.
     *
     * [WARNING]
     * ====
     * While an open way of calling {_snapshot} is required for certain trust minimization mechanisms such as forking,
     * you must consider that it can potentially be used by attackers in two ways.
     *
     * First, it can be used to increase the cost of retrieval of values from snapshots, although it will grow
     * logarithmically thus rendering this attack ineffective in the long term. Second, it can be used to target
     * specific accounts and increase the cost of ERC20 transfers for them, in the ways specified in the Gas Costs
     * section above.
     *
     * We haven't measured the actual numbers; if this is something you're interested in please reach out to us.
     * ====
     */
    function _snapshot() internal virtual returns (uint256) {
        _currentSnapshotId.increment();

        uint256 currentId = _getCurrentSnapshotId();
        emit Snapshot(currentId);
        return currentId;
    }

    /**
     * @dev Get the current snapshotId
     */
    function _getCurrentSnapshotId() internal view virtual returns (uint256) {
        return _currentSnapshotId.current();
    }

    /**
     * @dev Retrieves the balance of `account` at the time `snapshotId` was created.
     */
    function balanceOfAt(address account, uint256 snapshotId) public view virtual returns (uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]);

        return snapshotted ? value : balanceOf(account);
    }

    /**
     * @dev Retrieves the total supply at the time `snapshotId` was created.
     */
    function totalSupplyAt(uint256 snapshotId) public view virtual returns (uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnapshots);

        return snapshotted ? value : totalSupply();
    }

    // Update balance and/or total supply snapshots before the values are modified. This is implemented
    // in the _beforeTokenTransfer hook, which is executed for _mint, _burn, and _transfer operations.
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, amount);

        if (from == address(0)) {
            // mint
            _updateAccountSnapshot(to);
            _updateTotalSupplySnapshot();
        } else if (to == address(0)) {
            // burn
            _updateAccountSnapshot(from);
            _updateTotalSupplySnapshot();
        } else {
            // transfer
            _updateAccountSnapshot(from);
            _updateAccountSnapshot(to);
        }
    }

    function _valueAt(uint256 snapshotId, Snapshots storage snapshots) private view returns (bool, uint256) {
        require(snapshotId > 0, "ERC20Snapshot: id is 0");
        require(snapshotId <= _getCurrentSnapshotId(), "ERC20Snapshot: nonexistent id");

        // When a valid snapshot is queried, there are three possibilities:
        //  a) The queried value was not modified after the snapshot was taken. Therefore, a snapshot entry was never
        //  created for this id, and all stored snapshot ids are smaller than the requested one. The value that corresponds
        //  to this id is the current one.
        //  b) The queried value was modified after the snapshot was taken. Therefore, there will be an entry with the
        //  requested id, and its value is the one to return.
        //  c) More snapshots were created after the requested one, and the queried value was later modified. There will be
        //  no entry for the requested id: the value that corresponds to it is that of the smallest snapshot id that is
        //  larger than the requested one.
        //
        // In summary, we need to find an element in an array, returning the index of the smallest value that is larger if
        // it is not found, unless said value doesn't exist (e.g. when all values are smaller). Arrays.findUpperBound does
        // exactly this.

        uint256 index = snapshots.ids.findUpperBound(snapshotId);

        if (index == snapshots.ids.length) {
            return (false, 0);
        } else {
            return (true, snapshots.values[index]);
        }
    }

    function _updateAccountSnapshot(address account) private {
        _updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account));
    }

    function _updateTotalSupplySnapshot() private {
        _updateSnapshot(_totalSupplySnapshots, totalSupply());
    }

    function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private {
        uint256 currentId = _getCurrentSnapshotId();
        if (_lastSnapshotId(snapshots.ids) < currentId) {
            snapshots.ids.push(currentId);
            snapshots.values.push(currentValue);
        }
    }

    function _lastSnapshotId(uint256[] storage ids) private view returns (uint256) {
        if (ids.length == 0) {
            return 0;
        } else {
            return ids[ids.length - 1];
        }
    }
}

// File: contract-bbc0dcf24a.sol


pragma solidity 0.8.9;




/// @custom:security-contact [email protected]
contract FBXToken is ERC20Snapshot, Ownable, ERC20Pausable {
    constructor() ERC20("FBX Token", "FBX") {
        // Initial supply is 10.000.000.000 tokens with 18 decimals precision
        _mint(msg.sender, 10000000000 * 10 ** decimals());
    }

    function snapshot() public onlyOwner {
        _snapshot();
    }

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"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":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Snapshot","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":[{"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":"account","type":"address"},{"internalType":"uint256","name":"snapshotId","type":"uint256"}],"name":"balanceOfAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"snapshot","outputs":[],"stateMutability":"nonpayable","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":"uint256","name":"snapshotId","type":"uint256"}],"name":"totalSupplyAt","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":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

54053:712:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32458:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34809:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;33578:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35590:295;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;33420:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36294:238;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54458:65;;;:::i;:::-;;50035:266;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;25718:86;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;33749:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23228:103;;;:::i;:::-;;54389:61;;;:::i;:::-;;22580:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;32677:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54314:67;;;:::i;:::-;;50405:234;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;37035:436;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34082:193;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34338:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23486:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;32458:100;32512:13;32545:5;32538:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32458:100;:::o;34809:201::-;34892:4;34909:13;34925:12;:10;:12::i;:::-;34909:28;;34948:32;34957:5;34964:7;34973:6;34948:8;:32::i;:::-;34998:4;34991:11;;;34809:201;;;;:::o;33578:108::-;33639:7;33666:12;;33659:19;;33578:108;:::o;35590:295::-;35721:4;35738:15;35756:12;:10;:12::i;:::-;35738:30;;35779:38;35795:4;35801:7;35810:6;35779:15;:38::i;:::-;35828:27;35838:4;35844:2;35848:6;35828:9;:27::i;:::-;35873:4;35866:11;;;35590:295;;;;;:::o;33420:93::-;33478:5;33503:2;33496:9;;33420:93;:::o;36294:238::-;36382:4;36399:13;36415:12;:10;:12::i;:::-;36399:28;;36438:64;36447:5;36454:7;36491:10;36463:25;36473:5;36480:7;36463:9;:25::i;:::-;:38;;;;:::i;:::-;36438:8;:64::i;:::-;36520:4;36513:11;;;36294:238;;;;:::o;54458:65::-;22466:13;:11;:13::i;:::-;54505:10:::1;:8;:10::i;:::-;54458:65::o:0;50035:266::-;50122:7;50143:16;50161:13;50178:55;50187:10;50199:24;:33;50224:7;50199:33;;;;;;;;;;;;;;;50178:8;:55::i;:::-;50142:91;;;;50253:11;:40;;50275:18;50285:7;50275:9;:18::i;:::-;50253:40;;;50267:5;50253:40;50246:47;;;;50035:266;;;;:::o;25718:86::-;25765:4;25789:7;;;;;;;;;;;25782:14;;25718:86;:::o;33749:127::-;33823:7;33850:9;:18;33860:7;33850:18;;;;;;;;;;;;;;;;33843:25;;33749:127;;;:::o;23228:103::-;22466:13;:11;:13::i;:::-;23293:30:::1;23320:1;23293:18;:30::i;:::-;23228:103::o:0;54389:61::-;22466:13;:11;:13::i;:::-;54434:8:::1;:6;:8::i;:::-;54389:61::o:0;22580:87::-;22626:7;22653:6;;;;;;;;;;;22646:13;;22580:87;:::o;32677:104::-;32733:13;32766:7;32759:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32677:104;:::o;54314:67::-;22466:13;:11;:13::i;:::-;54362:11:::1;:9;:11::i;:::-;;54314:67::o:0;50405:234::-;50477:7;50498:16;50516:13;50533:43;50542:10;50554:21;50533:8;:43::i;:::-;50497:79;;;;50596:11;:35;;50618:13;:11;:13::i;:::-;50596:35;;;50610:5;50596:35;50589:42;;;;50405:234;;;:::o;37035:436::-;37128:4;37145:13;37161:12;:10;:12::i;:::-;37145:28;;37184:24;37211:25;37221:5;37228:7;37211:9;:25::i;:::-;37184:52;;37275:15;37255:16;:35;;37247:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;37368:60;37377:5;37384:7;37412:15;37393:16;:34;37368:8;:60::i;:::-;37459:4;37452:11;;;;37035:436;;;;:::o;34082:193::-;34161:4;34178:13;34194:12;:10;:12::i;:::-;34178:28;;34217;34227:5;34234:2;34238:6;34217:9;:28::i;:::-;34263:4;34256:11;;;34082:193;;;;:::o;34338:151::-;34427:7;34454:11;:18;34466:5;34454:18;;;;;;;;;;;;;;;:27;34473:7;34454:27;;;;;;;;;;;;;;;;34447:34;;34338:151;;;;:::o;23486:201::-;22466:13;:11;:13::i;:::-;23595:1:::1;23575:22;;:8;:22;;;;23567:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;23651:28;23670:8;23651:18;:28::i;:::-;23486:201:::0;:::o;44703:272::-;44846:44;44873:4;44879:2;44883:6;44846:26;:44::i;:::-;44912:8;:6;:8::i;:::-;44911:9;44903:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;44703:272;;;:::o;50856:622::-;50999:44;51026:4;51032:2;51036:6;50999:26;:44::i;:::-;51076:1;51060:18;;:4;:18;;;51056:415;;;51116:26;51139:2;51116:22;:26::i;:::-;51157:28;:26;:28::i;:::-;51056:415;;;51221:1;51207:16;;:2;:16;;;51203:268;;;51261:28;51284:4;51261:22;:28::i;:::-;51304;:26;:28::i;:::-;51203:268;;;51390:28;51413:4;51390:22;:28::i;:::-;51433:26;51456:2;51433:22;:26::i;:::-;51203:268;51056:415;50856:622;;;:::o;42786:125::-;;;;:::o;872:114::-;937:7;964;:14;;;957:21;;872:114;;;:::o;21131:98::-;21184:7;21211:10;21204:17;;21131:98;:::o;41062:380::-;41215:1;41198:19;;:5;:19;;;;41190:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;41296:1;41277:21;;:7;:21;;;;41269:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;41380:6;41350:11;:18;41362:5;41350:18;;;;;;;;;;;;;;;:27;41369:7;41350:27;;;;;;;;;;;;;;;:36;;;;41418:7;41402:32;;41411:5;41402:32;;;41427:6;41402:32;;;;;;:::i;:::-;;;;;;;;41062:380;;;:::o;41733:453::-;41868:24;41895:25;41905:5;41912:7;41895:9;:25::i;:::-;41868:52;;41955:17;41935:16;:37;41931:248;;42017:6;41997:16;:26;;41989:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;42101:51;42110:5;42117:7;42145:6;42126:16;:25;42101:8;:51::i;:::-;41931:248;41857:329;41733:453;;;:::o;37941:840::-;38088:1;38072:18;;:4;:18;;;;38064:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;38165:1;38151:16;;:2;:16;;;;38143:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;38220:38;38241:4;38247:2;38251:6;38220:20;:38::i;:::-;38271:19;38293:9;:15;38303:4;38293:15;;;;;;;;;;;;;;;;38271:37;;38342:6;38327:11;:21;;38319:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;38459:6;38445:11;:20;38427:9;:15;38437:4;38427:15;;;;;;;;;;;;;;;:38;;;;38662:6;38645:9;:13;38655:2;38645:13;;;;;;;;;;;;;;;;:23;;;;;;;;;;;38712:2;38697:26;;38706:4;38697:26;;;38716:6;38697:26;;;;;;:::i;:::-;;;;;;;;38736:37;38756:4;38762:2;38766:6;38736:19;:37::i;:::-;38053:728;37941:840;;;:::o;22745:132::-;22820:12;:10;:12::i;:::-;22809:23;;:7;:5;:7::i;:::-;:23;;;22801:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;22745:132::o;26573:120::-;25582:16;:14;:16::i;:::-;26642:5:::1;26632:7;;:15;;;;;;;;;;;;;;;;;;26663:22;26672:12;:10;:12::i;:::-;26663:22;;;;;;:::i;:::-;;;;;;;;26573:120::o:0;51486:1619::-;51575:4;51581:7;51622:1;51609:10;:14;51601:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;51683:23;:21;:23::i;:::-;51669:10;:37;;51661:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;52879:13;52895:40;52924:10;52895:9;:13;;:28;;:40;;;;:::i;:::-;52879:56;;52961:9;:13;;:20;;;;52952:5;:29;52948:150;;;53006:5;53013:1;52998:17;;;;;;;52948:150;53056:4;53062:9;:16;;53079:5;53062:23;;;;;;;;:::i;:::-;;;;;;;;;;53048:38;;;;;51486:1619;;;;;;:::o;23847:191::-;23921:16;23940:6;;;;;;;;;;;23921:25;;23966:8;23957:6;;:17;;;;;;;;;;;;;;;;;;24021:8;23990:40;;24011:8;23990:40;;;;;;;;;;;;23910:128;23847:191;:::o;26314:118::-;25323:19;:17;:19::i;:::-;26384:4:::1;26374:7;;:14;;;;;;;;;;;;;;;;;;26404:20;26411:12;:10;:12::i;:::-;26404:20;;;;;;:::i;:::-;;;;;;;;26314:118::o:0;49507:223::-;49554:7;49574:30;:18;:28;:30::i;:::-;49617:17;49637:23;:21;:23::i;:::-;49617:43;;49676:19;49685:9;49676:19;;;;;;:::i;:::-;;;;;;;;49713:9;49706:16;;;49507:223;:::o;53113:146::-;53181:70;53197:24;:33;53222:7;53197:33;;;;;;;;;;;;;;;53232:18;53242:7;53232:9;:18::i;:::-;53181:15;:70::i;:::-;53113:146;:::o;53267:118::-;53324:53;53340:21;53363:13;:11;:13::i;:::-;53324:15;:53::i;:::-;53267:118::o;54531:231::-;25323:19;:17;:19::i;:::-;54710:44:::1;54737:4;54743:2;54747:6;54710:26;:44::i;:::-;54531:231:::0;;;:::o;43515:124::-;;;;:::o;26062:108::-;26129:8;:6;:8::i;:::-;26121:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;26062:108::o;49796:127::-;49860:7;49887:28;:18;:26;:28::i;:::-;49880:35;;49796:127;:::o;17834:958::-;17923:7;17963:1;17947:5;:12;;;;:17;17943:58;;;17988:1;17981:8;;;;17943:58;18013:11;18039:12;18054:5;:12;;;;18039:27;;18079:444;18092:4;18086:3;:10;18079:444;;;18113:11;18127:23;18140:3;18145:4;18127:12;:23::i;:::-;18113:37;;18404:7;18371:24;18384:5;18391:3;18371:12;:24::i;:::-;:30;;;:40;18367:145;;;18439:3;18432:10;;18367:145;;;18495:1;18489:3;:7;;;;:::i;:::-;18483:13;;18367:145;18098:425;18079:444;;;18649:1;18643:3;:7;:56;;;;;18692:7;18654:28;18667:5;18680:1;18674:3;:7;;;;:::i;:::-;18654:12;:28::i;:::-;:34;;;:45;18643:56;18639:146;;;18729:1;18723:3;:7;;;;:::i;:::-;18716:14;;;;;;18639:146;18770:3;18763:10;;;;17834:958;;;;;:::o;25877:108::-;25948:8;:6;:8::i;:::-;25947:9;25939:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;25877:108::o;994:127::-;1101:1;1083:7;:14;;;:19;;;;;;;;;;;994:127;:::o;53393:310::-;53488:17;53508:23;:21;:23::i;:::-;53488:43;;53579:9;53546:30;53562:9;:13;;53546:15;:30::i;:::-;:42;53542:154;;;53605:9;:13;;53624:9;53605:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53649:9;:16;;53671:12;53649:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53542:154;53477:226;53393:310;;:::o;2328:156::-;2390:7;2475:1;2470;2466;:5;2465:11;;;;:::i;:::-;2460:1;2456;:5;2455:21;;;;:::i;:::-;2448:28;;2328:156;;;;:::o;20103:342::-;20184:31;20228:12;20329:8;20326:1;20319:19;20384:3;20377:4;20374:1;20364:18;20360:28;20352:36;;20416:21;:4;:19;:21::i;:::-;20409:28;;;20103:342;;;;:::o;53711:212::-;53781:7;53819:1;53805:3;:10;;;;:15;53801:115;;;53844:1;53837:8;;;;53801:115;53885:3;53902:1;53889:3;:10;;;;:14;;;;:::i;:::-;53885:19;;;;;;;;:::i;:::-;;;;;;;;;;53878:26;;53711:212;;;;:::o;16928:195::-;16989:21;17101:4;17091:14;;16928:195;;;:::o;7:99:1:-;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:307::-;355:1;365:113;379:6;376:1;373:13;365:113;;;464:1;459:3;455:11;449:18;445:1;440:3;436:11;429:39;401:2;398:1;394:10;389:15;;365:113;;;496:6;493:1;490:13;487:101;;;576:1;567:6;562:3;558:16;551:27;487:101;336:258;287:307;;;:::o;600:102::-;641:6;692:2;688:7;683:2;676:5;672:14;668:28;658:38;;600:102;;;:::o;708:364::-;796:3;824:39;857:5;824:39;:::i;:::-;879:71;943:6;938:3;879:71;:::i;:::-;872:78;;959:52;1004:6;999:3;992:4;985:5;981:16;959:52;:::i;:::-;1036:29;1058:6;1036:29;:::i;:::-;1031:3;1027:39;1020:46;;800:272;708:364;;;;:::o;1078:313::-;1191:4;1229:2;1218:9;1214:18;1206:26;;1278:9;1272:4;1268:20;1264:1;1253:9;1249:17;1242:47;1306:78;1379:4;1370:6;1306:78;:::i;:::-;1298:86;;1078:313;;;;:::o;1478:117::-;1587:1;1584;1577:12;1724:126;1761:7;1801:42;1794:5;1790:54;1779:65;;1724:126;;;:::o;1856:96::-;1893:7;1922:24;1940:5;1922:24;:::i;:::-;1911:35;;1856:96;;;:::o;1958:122::-;2031:24;2049:5;2031:24;:::i;:::-;2024:5;2021:35;2011:63;;2070:1;2067;2060:12;2011:63;1958:122;:::o;2086:139::-;2132:5;2170:6;2157:20;2148:29;;2186:33;2213:5;2186:33;:::i;:::-;2086:139;;;;:::o;2231:77::-;2268:7;2297:5;2286:16;;2231:77;;;:::o;2314:122::-;2387:24;2405:5;2387:24;:::i;:::-;2380:5;2377:35;2367:63;;2426:1;2423;2416:12;2367:63;2314:122;:::o;2442:139::-;2488:5;2526:6;2513:20;2504:29;;2542:33;2569:5;2542:33;:::i;:::-;2442:139;;;;:::o;2587:474::-;2655:6;2663;2712:2;2700:9;2691:7;2687:23;2683:32;2680:119;;;2718:79;;:::i;:::-;2680:119;2838:1;2863:53;2908:7;2899:6;2888:9;2884:22;2863:53;:::i;:::-;2853:63;;2809:117;2965:2;2991:53;3036:7;3027:6;3016:9;3012:22;2991:53;:::i;:::-;2981:63;;2936:118;2587:474;;;;;:::o;3067:90::-;3101:7;3144:5;3137:13;3130:21;3119:32;;3067:90;;;:::o;3163:109::-;3244:21;3259:5;3244:21;:::i;:::-;3239:3;3232:34;3163:109;;:::o;3278:210::-;3365:4;3403:2;3392:9;3388:18;3380:26;;3416:65;3478:1;3467:9;3463:17;3454:6;3416:65;:::i;:::-;3278:210;;;;:::o;3494:118::-;3581:24;3599:5;3581:24;:::i;:::-;3576:3;3569:37;3494:118;;:::o;3618:222::-;3711:4;3749:2;3738:9;3734:18;3726:26;;3762:71;3830:1;3819:9;3815:17;3806:6;3762:71;:::i;:::-;3618:222;;;;:::o;3846:619::-;3923:6;3931;3939;3988:2;3976:9;3967:7;3963:23;3959:32;3956:119;;;3994:79;;:::i;:::-;3956:119;4114:1;4139:53;4184:7;4175:6;4164:9;4160:22;4139:53;:::i;:::-;4129:63;;4085:117;4241:2;4267:53;4312:7;4303:6;4292:9;4288:22;4267:53;:::i;:::-;4257:63;;4212:118;4369:2;4395:53;4440:7;4431:6;4420:9;4416:22;4395:53;:::i;:::-;4385:63;;4340:118;3846:619;;;;;:::o;4471:86::-;4506:7;4546:4;4539:5;4535:16;4524:27;;4471:86;;;:::o;4563:112::-;4646:22;4662:5;4646:22;:::i;:::-;4641:3;4634:35;4563:112;;:::o;4681:214::-;4770:4;4808:2;4797:9;4793:18;4785:26;;4821:67;4885:1;4874:9;4870:17;4861:6;4821:67;:::i;:::-;4681:214;;;;:::o;4901:329::-;4960:6;5009:2;4997:9;4988:7;4984:23;4980:32;4977:119;;;5015:79;;:::i;:::-;4977:119;5135:1;5160:53;5205:7;5196:6;5185:9;5181:22;5160:53;:::i;:::-;5150:63;;5106:117;4901:329;;;;:::o;5236:118::-;5323:24;5341:5;5323:24;:::i;:::-;5318:3;5311:37;5236:118;;:::o;5360:222::-;5453:4;5491:2;5480:9;5476:18;5468:26;;5504:71;5572:1;5561:9;5557:17;5548:6;5504:71;:::i;:::-;5360:222;;;;:::o;5588:329::-;5647:6;5696:2;5684:9;5675:7;5671:23;5667:32;5664:119;;;5702:79;;:::i;:::-;5664:119;5822:1;5847:53;5892:7;5883:6;5872:9;5868:22;5847:53;:::i;:::-;5837:63;;5793:117;5588:329;;;;:::o;5923:474::-;5991:6;5999;6048:2;6036:9;6027:7;6023:23;6019:32;6016:119;;;6054:79;;:::i;:::-;6016:119;6174:1;6199:53;6244:7;6235:6;6224:9;6220:22;6199:53;:::i;:::-;6189:63;;6145:117;6301:2;6327:53;6372:7;6363:6;6352:9;6348:22;6327:53;:::i;:::-;6317:63;;6272:118;5923:474;;;;;:::o;6403:180::-;6451:77;6448:1;6441:88;6548:4;6545:1;6538:15;6572:4;6569:1;6562:15;6589:320;6633:6;6670:1;6664:4;6660:12;6650:22;;6717:1;6711:4;6707:12;6738:18;6728:81;;6794:4;6786:6;6782:17;6772:27;;6728:81;6856:2;6848:6;6845:14;6825:18;6822:38;6819:84;;;6875:18;;:::i;:::-;6819:84;6640:269;6589:320;;;:::o;6915:180::-;6963:77;6960:1;6953:88;7060:4;7057:1;7050:15;7084:4;7081:1;7074:15;7101:305;7141:3;7160:20;7178:1;7160:20;:::i;:::-;7155:25;;7194:20;7212:1;7194:20;:::i;:::-;7189:25;;7348:1;7280:66;7276:74;7273:1;7270:81;7267:107;;;7354:18;;:::i;:::-;7267:107;7398:1;7395;7391:9;7384:16;;7101:305;;;;:::o;7412:224::-;7552:34;7548:1;7540:6;7536:14;7529:58;7621:7;7616:2;7608:6;7604:15;7597:32;7412:224;:::o;7642:366::-;7784:3;7805:67;7869:2;7864:3;7805:67;:::i;:::-;7798:74;;7881:93;7970:3;7881:93;:::i;:::-;7999:2;7994:3;7990:12;7983:19;;7642:366;;;:::o;8014:419::-;8180:4;8218:2;8207:9;8203:18;8195:26;;8267:9;8261:4;8257:20;8253:1;8242:9;8238:17;8231:47;8295:131;8421:4;8295:131;:::i;:::-;8287:139;;8014:419;;;:::o;8439:225::-;8579:34;8575:1;8567:6;8563:14;8556:58;8648:8;8643:2;8635:6;8631:15;8624:33;8439:225;:::o;8670:366::-;8812:3;8833:67;8897:2;8892:3;8833:67;:::i;:::-;8826:74;;8909:93;8998:3;8909:93;:::i;:::-;9027:2;9022:3;9018:12;9011:19;;8670:366;;;:::o;9042:419::-;9208:4;9246:2;9235:9;9231:18;9223:26;;9295:9;9289:4;9285:20;9281:1;9270:9;9266:17;9259:47;9323:131;9449:4;9323:131;:::i;:::-;9315:139;;9042:419;;;:::o;9467:229::-;9607:34;9603:1;9595:6;9591:14;9584:58;9676:12;9671:2;9663:6;9659:15;9652:37;9467:229;:::o;9702:366::-;9844:3;9865:67;9929:2;9924:3;9865:67;:::i;:::-;9858:74;;9941:93;10030:3;9941:93;:::i;:::-;10059:2;10054:3;10050:12;10043:19;;9702:366;;;:::o;10074:419::-;10240:4;10278:2;10267:9;10263:18;10255:26;;10327:9;10321:4;10317:20;10313:1;10302:9;10298:17;10291:47;10355:131;10481:4;10355:131;:::i;:::-;10347:139;;10074:419;;;:::o;10499:223::-;10639:34;10635:1;10627:6;10623:14;10616:58;10708:6;10703:2;10695:6;10691:15;10684:31;10499:223;:::o;10728:366::-;10870:3;10891:67;10955:2;10950:3;10891:67;:::i;:::-;10884:74;;10967:93;11056:3;10967:93;:::i;:::-;11085:2;11080:3;11076:12;11069:19;;10728:366;;;:::o;11100:419::-;11266:4;11304:2;11293:9;11289:18;11281:26;;11353:9;11347:4;11343:20;11339:1;11328:9;11324:17;11317:47;11381:131;11507:4;11381:131;:::i;:::-;11373:139;;11100:419;;;:::o;11525:221::-;11665:34;11661:1;11653:6;11649:14;11642:58;11734:4;11729:2;11721:6;11717:15;11710:29;11525:221;:::o;11752:366::-;11894:3;11915:67;11979:2;11974:3;11915:67;:::i;:::-;11908:74;;11991:93;12080:3;11991:93;:::i;:::-;12109:2;12104:3;12100:12;12093:19;;11752:366;;;:::o;12124:419::-;12290:4;12328:2;12317:9;12313:18;12305:26;;12377:9;12371:4;12367:20;12363:1;12352:9;12348:17;12341:47;12405:131;12531:4;12405:131;:::i;:::-;12397:139;;12124:419;;;:::o;12549:179::-;12689:31;12685:1;12677:6;12673:14;12666:55;12549:179;:::o;12734:366::-;12876:3;12897:67;12961:2;12956:3;12897:67;:::i;:::-;12890:74;;12973:93;13062:3;12973:93;:::i;:::-;13091:2;13086:3;13082:12;13075:19;;12734:366;;;:::o;13106:419::-;13272:4;13310:2;13299:9;13295:18;13287:26;;13359:9;13353:4;13349:20;13345:1;13334:9;13330:17;13323:47;13387:131;13513:4;13387:131;:::i;:::-;13379:139;;13106:419;;;:::o;13531:224::-;13671:34;13667:1;13659:6;13655:14;13648:58;13740:7;13735:2;13727:6;13723:15;13716:32;13531:224;:::o;13761:366::-;13903:3;13924:67;13988:2;13983:3;13924:67;:::i;:::-;13917:74;;14000:93;14089:3;14000:93;:::i;:::-;14118:2;14113:3;14109:12;14102:19;;13761:366;;;:::o;14133:419::-;14299:4;14337:2;14326:9;14322:18;14314:26;;14386:9;14380:4;14376:20;14372:1;14361:9;14357:17;14350:47;14414:131;14540:4;14414:131;:::i;:::-;14406:139;;14133:419;;;:::o;14558:222::-;14698:34;14694:1;14686:6;14682:14;14675:58;14767:5;14762:2;14754:6;14750:15;14743:30;14558:222;:::o;14786:366::-;14928:3;14949:67;15013:2;15008:3;14949:67;:::i;:::-;14942:74;;15025:93;15114:3;15025:93;:::i;:::-;15143:2;15138:3;15134:12;15127:19;;14786:366;;;:::o;15158:419::-;15324:4;15362:2;15351:9;15347:18;15339:26;;15411:9;15405:4;15401:20;15397:1;15386:9;15382:17;15375:47;15439:131;15565:4;15439:131;:::i;:::-;15431:139;;15158:419;;;:::o;15583:225::-;15723:34;15719:1;15711:6;15707:14;15700:58;15792:8;15787:2;15779:6;15775:15;15768:33;15583:225;:::o;15814:366::-;15956:3;15977:67;16041:2;16036:3;15977:67;:::i;:::-;15970:74;;16053:93;16142:3;16053:93;:::i;:::-;16171:2;16166:3;16162:12;16155:19;;15814:366;;;:::o;16186:419::-;16352:4;16390:2;16379:9;16375:18;16367:26;;16439:9;16433:4;16429:20;16425:1;16414:9;16410:17;16403:47;16467:131;16593:4;16467:131;:::i;:::-;16459:139;;16186:419;;;:::o;16611:182::-;16751:34;16747:1;16739:6;16735:14;16728:58;16611:182;:::o;16799:366::-;16941:3;16962:67;17026:2;17021:3;16962:67;:::i;:::-;16955:74;;17038:93;17127:3;17038:93;:::i;:::-;17156:2;17151:3;17147:12;17140:19;;16799:366;;;:::o;17171:419::-;17337:4;17375:2;17364:9;17360:18;17352:26;;17424:9;17418:4;17414:20;17410:1;17399:9;17395:17;17388:47;17452:131;17578:4;17452:131;:::i;:::-;17444:139;;17171:419;;;:::o;17596:172::-;17736:24;17732:1;17724:6;17720:14;17713:48;17596:172;:::o;17774:366::-;17916:3;17937:67;18001:2;17996:3;17937:67;:::i;:::-;17930:74;;18013:93;18102:3;18013:93;:::i;:::-;18131:2;18126:3;18122:12;18115:19;;17774:366;;;:::o;18146:419::-;18312:4;18350:2;18339:9;18335:18;18327:26;;18399:9;18393:4;18389:20;18385:1;18374:9;18370:17;18363:47;18427:131;18553:4;18427:131;:::i;:::-;18419:139;;18146:419;;;:::o;18571:179::-;18711:31;18707:1;18699:6;18695:14;18688:55;18571:179;:::o;18756:366::-;18898:3;18919:67;18983:2;18978:3;18919:67;:::i;:::-;18912:74;;18995:93;19084:3;18995:93;:::i;:::-;19113:2;19108:3;19104:12;19097:19;;18756:366;;;:::o;19128:419::-;19294:4;19332:2;19321:9;19317:18;19309:26;;19381:9;19375:4;19371:20;19367:1;19356:9;19352:17;19345:47;19409:131;19535:4;19409:131;:::i;:::-;19401:139;;19128:419;;;:::o;19553:180::-;19601:77;19598:1;19591:88;19698:4;19695:1;19688:15;19722:4;19719:1;19712:15;19739:170;19879:22;19875:1;19867:6;19863:14;19856:46;19739:170;:::o;19915:366::-;20057:3;20078:67;20142:2;20137:3;20078:67;:::i;:::-;20071:74;;20154:93;20243:3;20154:93;:::i;:::-;20272:2;20267:3;20263:12;20256:19;;19915:366;;;:::o;20287:419::-;20453:4;20491:2;20480:9;20476:18;20468:26;;20540:9;20534:4;20530:20;20526:1;20515:9;20511:17;20504:47;20568:131;20694:4;20568:131;:::i;:::-;20560:139;;20287:419;;;:::o;20712:191::-;20752:4;20772:20;20790:1;20772:20;:::i;:::-;20767:25;;20806:20;20824:1;20806:20;:::i;:::-;20801:25;;20845:1;20842;20839:8;20836:34;;;20850:18;;:::i;:::-;20836:34;20895:1;20892;20888:9;20880:17;;20712:191;;;;:::o;20909:166::-;21049:18;21045:1;21037:6;21033:14;21026:42;20909:166;:::o;21081:366::-;21223:3;21244:67;21308:2;21303:3;21244:67;:::i;:::-;21237:74;;21320:93;21409:3;21320:93;:::i;:::-;21438:2;21433:3;21429:12;21422:19;;21081:366;;;:::o;21453:419::-;21619:4;21657:2;21646:9;21642:18;21634:26;;21706:9;21700:4;21696:20;21692:1;21681:9;21677:17;21670:47;21734:131;21860:4;21734:131;:::i;:::-;21726:139;;21453:419;;;:::o;21878:180::-;21926:77;21923:1;21916:88;22023:4;22020:1;22013:15;22047:4;22044:1;22037:15;22064:185;22104:1;22121:20;22139:1;22121:20;:::i;:::-;22116:25;;22155:20;22173:1;22155:20;:::i;:::-;22150:25;;22194:1;22184:35;;22199:18;;:::i;:::-;22184:35;22241:1;22238;22234:9;22229:14;;22064:185;;;;:::o

ipfs://fc3c4bf46001f9102f84a682c7426d443be8e9c1a00c2964dc576c5c0b5bed7a