// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {Fuzzlib} from "./Fuzzlib.sol";
import {PlatformCrytic} from "./platform/PlatformCrytic.sol";

abstract contract FuzzBase {
    Fuzzlib internal fl = new Fuzzlib();

    constructor() {
        fl.setPlatform(address(new PlatformCrytic()));
    }
}


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/// @notice Efficient library for creating string representations of integers.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)
/// @author Modified from Solady (https://github.com/Vectorized/solady/blob/main/src/utils/LibString.sol)
/// @author Modified from Crytic Properties (https://github.com/crytic/properties/blob/main/contracts/util/PropertiesHelper.sol)
library FuzzLibString {
    bytes16 internal constant HEX_DIGITS = "0123456789abcdef";

    function toString(int256 value) internal pure returns (string memory str) {
        uint256 absValue = value >= 0 ? uint256(value) : uint256(-value);
        str = toString(absValue);

        if (value < 0) {
            str = string(abi.encodePacked("-", str));
        }
    }

    function toString(uint256 value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit), but we allocate 160 bytes
            // to keep the free memory pointer word aligned. We'll need 1 word for the length, 1 word for the
            // trailing zeros padding, and 3 other words for a max of 78 digits. In total: 5 * 32 = 160 bytes.
            let newFreeMemoryPointer := add(mload(0x40), 160)

            // Update the free memory pointer to avoid overriding our string.
            mstore(0x40, newFreeMemoryPointer)

            // Assign str to the end of the zone of newly allocated memory.
            str := sub(newFreeMemoryPointer, 32)

            // Clean the last word of memory it may not be overwritten.
            mstore(str, 0)

            // Cache the end of the memory to calculate the length later.
            let end := str

            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            // prettier-ignore
            for { let temp := value } 1 {} {
                // Move the pointer 1 byte to the left.
                str := sub(str, 1)

                // Write the character to the pointer.
                // The ASCII index of the '0' character is 48.
                mstore8(str, add(48, mod(temp, 10)))

                // Keep dividing temp until zero.
                temp := div(temp, 10)

                 // prettier-ignore
                if iszero(temp) { break }
            }

            // Compute and cache the final total length of the string.
            let length := sub(end, str)

            // Move the pointer 32 bytes leftwards to make room for the length.
            str := sub(str, 32)

            // Store the string's length at the start of memory allocated for our string.
            mstore(str, length)
        }
    }

    function toString(address value) internal pure returns (string memory str) {
        bytes memory s = new bytes(40);
        for (uint256 i = 0; i < 20; i++) {
            bytes1 b = bytes1(
                uint8(uint256(uint160(value)) / (2**(8 * (19 - i))))
            );
            bytes1 hi = bytes1(uint8(b) / 16);
            bytes1 lo = bytes1(uint8(b) - 16 * uint8(hi));
            s[2 * i] = char(hi);
            s[2 * i + 1] = char(lo);
        }
        return string(s);
    }

    function char(bytes1 b) internal pure returns (bytes1 c) {
        if (uint8(b) < 10) return bytes1(uint8(b) + 0x30);
        else return bytes1(uint8(b) + 0x57);
    }

    // based on OZ's toHexString
    // https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Strings.sol
    function toHexString(bytes memory value)
        internal
        pure
        returns (string memory)
    {
        bytes memory buffer = new bytes(2 * value.length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 0; i < value.length; i++) {
            uint8 valueByte = uint8(value[i]);
            buffer[2 * i + 2] = HEX_DIGITS[valueByte >> 4];
            buffer[2 * i + 3] = HEX_DIGITS[valueByte & 0xf];
        }
        return string(buffer);
    }

    // https://ethereum.stackexchange.com/a/83577
    function getRevertMsg(bytes memory returnData)
        internal
        pure
        returns (string memory)
    {
        // Check that the data has the right size: 4 bytes for signature + 32 bytes for panic code
        if (returnData.length == 4 + 32) {
            // Check that the data starts with the Panic signature
            bytes4 panicSignature = bytes4(keccak256(bytes("Panic(uint256)")));
            for (uint256 i = 0; i < 4; i++) {
                if (returnData[i] != panicSignature[i])
                    return "Undefined signature";
            }

            uint256 panicCode;
            for (uint256 i = 4; i < 36; i++) {
                panicCode = panicCode << 8;
                panicCode |= uint8(returnData[i]);
            }

            // Now convert the panic code into its string representation
            if (panicCode == 17) {
                return "Panic(17)";
            }

            // Add other panic codes as needed or return a generic "Unknown panic"
            return "Undefined panic code";
        }

        // If the returnData length is less than 68, then the transaction failed silently (without a revert message)
        if (returnData.length < 68) return "Transaction reverted silently";

        assembly {
            // Slice the sighash.
            returnData := add(returnData, 0x04)
        }
        return abi.decode(returnData, (string)); // All that remains is the revert string
    }

    function isRevertReasonEqual(bytes memory returnData, string memory reason)
        internal
        pure
        returns (bool)
    {
        return (keccak256(abi.encodePacked(getRevertMsg(returnData))) ==
            keccak256(abi.encodePacked(reason)));
    }
}


returnData

reason

assertRevertReasonEqual

reason1

reason2

reason3

reason4

assertRevertReasonNotEqual

value

high

enableLogs

clamp

clampGt

clampGte

clampLt

clampLte

diff

errorSelector

allowedErrors

message

errAllow

messages

errsAllow

data

logFail

platform

_platform

setPlatform

shuffle

entropy

shuffleArray

AssertEqFail

AssertFail

AssertGtFail

AssertGteFail

AssertLtFail

AssertLteFail

AssertNeqFail

AssertionFailed

Clamped

LogAddress

LogBool

LogBytes

LogBytes32

LogInt

LogString

LogUint

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {HelperBase} from "./helpers/HelperBase.sol";
import {HelperAssert} from "./helpers/HelperAssert.sol";
import {HelperClamp} from "./helpers/HelperClamp.sol";
import {HelperLog} from "./helpers/HelperLog.sol";
import {HelperMath} from "./helpers/HelperMath.sol";
import {HelperRandom} from "./helpers/HelperRandom.sol";

contract Fuzzlib is
    HelperBase,
    HelperAssert,
    HelperClamp,
    HelperLog,
    HelperMath,
    HelperRandom
{}


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "./HelperBase.sol";

import "../FuzzLibString.sol";

/// @author Based on Crytic PropertiesHelper (https://github.com/crytic/properties/blob/main/contracts/util/PropertiesHelper.sol)
abstract contract HelperAssert is HelperBase {
    event AssertFail(string);
    event AssertEqFail(string);
    event AssertNeqFail(string);
    event AssertGteFail(string);
    event AssertGtFail(string);
    event AssertLteFail(string);
    event AssertLtFail(string);

    function t(bool b, string memory reason) public {
        if (!b) {
            emit AssertFail(reason);
            platform.assertFail();
        }
    }

    /// @notice asserts that a is equal to b. Violations are logged using reason.
    function eq(
        uint256 a,
        uint256 b,
        string memory reason
    ) public {
        if (a != b) {
            string memory aStr = FuzzLibString.toString(a);
            string memory bStr = FuzzLibString.toString(b);
            string memory assertMsg = createAssertFailMessage(aStr, bStr, "!=", reason);
            emit AssertEqFail(assertMsg);
            platform.assertFail();
        }
    }

    /// @notice int256 version of eq
    function eq(
        int256 a,
        int256 b,
        string memory reason
    ) public {
        if (a != b) {
            string memory aStr = FuzzLibString.toString(a);
            string memory bStr = FuzzLibString.toString(b);
            string memory assertMsg = createAssertFailMessage(aStr, bStr, "!=", reason);
           emit AssertEqFail(assertMsg);
            platform.assertFail();
        }
    }

    /// @notice bool version of eq
    function eq(
        bool a,
        bool b,
        string memory reason
    ) public {
        if (a != b) {
            string memory aStr = a ? "true" : "false";
            string memory bStr = b ? "true" : "false";
            string memory assertMsg = createAssertFailMessage(aStr, bStr, "!=", reason);
            emit AssertEqFail(assertMsg);
            platform.assertFail();
        }
    }

    /// @notice address version of eq
    function eq(
        address a,
        address b,
        string memory reason
    ) public {
        if (a != b) {
            string memory aStr = FuzzLibString.toString(a);
            string memory bStr = FuzzLibString.toString(b);
            string memory assertMsg = createAssertFailMessage(aStr, bStr, "!=", reason);
            emit AssertEqFail(assertMsg);
            platform.assertFail();
        }
    }

    /// @notice bytes4 version of eq
    function eq(
        bytes4 a,
        bytes4 b,
        string memory reason
    ) public {
        if (a != b) {
            bytes memory aBytes = abi.encodePacked(a);
            bytes memory bBytes = abi.encodePacked(b);
            string memory aStr = FuzzLibString.toHexString(aBytes);
            string memory bStr = FuzzLibString.toHexString(bBytes);
            string memory assertMsg = createAssertFailMessage(aStr, bStr, "!=", reason);
            emit AssertEqFail(assertMsg);
            platform.assertFail();
        }
    }

    /// @notice asserts that a is not equal to b. Violations are logged using reason.
    function neq(
        uint256 a,
        uint256 b,
        string memory reason
    ) public {
        if (a == b) {
            string memory aStr = FuzzLibString.toString(a);
            string memory bStr = FuzzLibString.toString(b);
            string memory assertMsg = createAssertFailMessage(aStr, bStr, "==", reason);
            emit AssertNeqFail(assertMsg);
            platform.assertFail();
        }
    }

    /// @notice int256 version of neq
    function neq(
        int256 a,
        int256 b,
        string memory reason
    ) public {
        if (a == b) {
            string memory aStr = FuzzLibString.toString(a);
            string memory bStr = FuzzLibString.toString(b);
            string memory assertMsg = createAssertFailMessage(aStr, bStr, "==", reason);
            emit AssertNeqFail(assertMsg);
            platform.assertFail();
        }
    }

    /// @notice asserts that a is greater than or equal to b. Violations are logged using reason.
    function gte(
        uint256 a,
        uint256 b,
        string memory reason
    ) public {
        if (!(a >= b)) {
            string memory aStr = FuzzLibString.toString(a);
            string memory bStr = FuzzLibString.toString(b);
            string memory assertMsg = createAssertFailMessage(aStr, bStr, "<", reason);
            emit AssertGteFail(assertMsg);
            platform.assertFail();
        }
    }

    /// @notice int256 version of gte
    function gte(
        int256 a,
        int256 b,
        string memory reason
    ) public {
        if (!(a >= b)) {
            string memory aStr = FuzzLibString.toString(a);
            string memory bStr = FuzzLibString.toString(b);
            string memory assertMsg = createAssertFailMessage(aStr, bStr, "<", reason);
            emit AssertGteFail(assertMsg);
            platform.assertFail();
        }
    }

    /// @notice asserts that a is greater than b. Violations are logged using reason.
    function gt(
        uint256 a,
        uint256 b,
        string memory reason
    ) public {
        if (!(a > b)) {
            string memory aStr = FuzzLibString.toString(a);
            string memory bStr = FuzzLibString.toString(b);
            string memory assertMsg = createAssertFailMessage(aStr, bStr, "<=", reason);
            emit AssertGtFail(assertMsg);
            platform.assertFail();
        }
    }

    /// @notice int256 version of gt
    function gt(
        int256 a,
        int256 b,
        string memory reason
    ) public {
        if (!(a > b)) {
            string memory aStr = FuzzLibString.toString(a);
            string memory bStr = FuzzLibString.toString(b);
            string memory assertMsg = createAssertFailMessage(aStr, bStr, "<=", reason);
            emit AssertGtFail(assertMsg);
            platform.assertFail();
        }
    }

    /// @notice asserts that a is less than or equal to b. Violations are logged using reason.
    function lte(
        uint256 a,
        uint256 b,
        string memory reason
    ) public {
        if (!(a <= b)) {
            string memory aStr = FuzzLibString.toString(a);
            string memory bStr = FuzzLibString.toString(b);
            string memory assertMsg = createAssertFailMessage(aStr, bStr, ">", reason);
            emit AssertLteFail(assertMsg);
            platform.assertFail();
        }
    }

    /// @notice int256 version of lte
    function lte(
        int256 a,
        int256 b,
        string memory reason
    ) public {
        if (!(a <= b)) {
            string memory aStr = FuzzLibString.toString(a);
            string memory bStr = FuzzLibString.toString(b);
            string memory assertMsg = createAssertFailMessage(aStr, bStr, ">", reason);
            emit AssertLteFail(assertMsg);
            platform.assertFail();
        }
    }

    /// @notice asserts that a is less than b. Violations are logged using reason.
    function lt(
        uint256 a,
        uint256 b,
        string memory reason
    ) public {
        if (!(a < b)) {
            string memory aStr = FuzzLibString.toString(a);
            string memory bStr = FuzzLibString.toString(b);
            string memory assertMsg = createAssertFailMessage(aStr, bStr, ">=", reason);
            emit AssertLtFail(assertMsg);
            platform.assertFail();
        }
    }

    /// @notice int256 version of lt
    function lt(
        int256 a,
        int256 b,
        string memory reason
    ) public {
        if (!(a < b)) {
            string memory aStr = FuzzLibString.toString(a);
            string memory bStr = FuzzLibString.toString(b);
            string memory assertMsg = createAssertFailMessage(aStr, bStr, ">=", reason);
            emit AssertLtFail(assertMsg);
            platform.assertFail();
        }
    }

    function assertRevertReasonNotEqual(
        bytes memory returnData,
        string memory reason
    ) public {
        bool isEqual = FuzzLibString.isRevertReasonEqual(returnData, reason);
        t(!isEqual, reason);
    }

    function assertRevertReasonEqual(
        bytes memory returnData,
        string memory reason
    ) public {
        bool isEqual = FuzzLibString.isRevertReasonEqual(returnData, reason);
        t(isEqual, reason);
    }

    function assertRevertReasonEqual(
        bytes memory returnData,
        string memory reason1,
        string memory reason2
    ) public {
        bool isEqual = FuzzLibString.isRevertReasonEqual(returnData, reason1) ||
            FuzzLibString.isRevertReasonEqual(returnData, reason2);
        string memory assertMsg = string(
            abi.encodePacked(reason1, " OR ", reason2)
        );
        t(isEqual, assertMsg);
    }

    function assertRevertReasonEqual(
        bytes memory returnData,
        string memory reason1,
        string memory reason2,
        string memory reason3
    ) public {
        bool isEqual = FuzzLibString.isRevertReasonEqual(returnData, reason1) ||
            FuzzLibString.isRevertReasonEqual(returnData, reason2) ||
            FuzzLibString.isRevertReasonEqual(returnData, reason3);
        string memory assertMsg = string(
            abi.encodePacked(reason1, " OR ", reason2, " OR ", reason3)
        );
        t(isEqual, assertMsg);
    }

    function assertRevertReasonEqual(
        bytes memory returnData,
        string memory reason1,
        string memory reason2,
        string memory reason3,
        string memory reason4
    ) public {
        bool isEqual = FuzzLibString.isRevertReasonEqual(returnData, reason1) ||
            FuzzLibString.isRevertReasonEqual(returnData, reason2) ||
            FuzzLibString.isRevertReasonEqual(returnData, reason3) ||
            FuzzLibString.isRevertReasonEqual(returnData, reason4);
        string memory assertMsg = string(
            abi.encodePacked(
                reason1,
                " OR ",
                reason2,
                " OR ",
                reason3,
                " OR ",
                reason4
            )
        );
        t(isEqual, assertMsg);
    }

    function errAllow(
        bytes4 errorSelector,
        bytes4[] memory allowedErrors,
        string memory message
    ) public {
        bool allowed = false;
        for (uint256 i = 0; i < allowedErrors.length; i++) {
            if (errorSelector == allowedErrors[i]) {
                allowed = true;
                break;
            }
        }
        t(allowed, message);
    }

    function errsAllow(
        bytes4 errorSelector,
        bytes4[] memory allowedErrors,
        string[] memory messages
    ) public {
        bool allowed = false;
        uint256 passIndex = 0;
        for (uint256 i = 0; i < allowedErrors.length; i++) {
            if (errorSelector == allowedErrors[i]) {
                allowed = true;
                passIndex = i;
                break;
            }
        }
        t(allowed, messages[passIndex]);
    }

    function createAssertFailMessage(string memory aStr, string memory bStr, string memory operator, string memory reason)internal pure returns (string memory) {
        return string(abi.encodePacked("Invalid: ", aStr, operator, bStr, ", reason: ", reason));
    }

}


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {IPlatform} from "../platform/IPlatform.sol";

contract HelperBase {
    IPlatform public platform;

    function setPlatform(address _platform) public {
        platform = IPlatform(_platform);
    }
}


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "../FuzzLibString.sol";
import "./HelperAssert.sol";

/// @author Based on Crytic PropertiesHelper (https://github.com/crytic/properties/blob/main/contracts/util/PropertiesHelper.sol)
abstract contract HelperClamp is HelperAssert {
    event Clamped(string);

    /*
     **************************************************************************
     * Clamp functions with logging enabled
     **************************************************************************
     */

    /// @notice Clamps value to be between low and high, both inclusive
    function clamp(
        uint256 value,
        uint256 low,
        uint256 high
    ) public returns (uint256) {
        return clamp(value, low, high, true);
    }

    /// @notice int256 version of clamp
    function clamp(
        int256 value,
        int256 low,
        int256 high
    ) public returns (int256) {
        return clamp(value, low, high, true);
    }

    /// @notice clamps a to be less than b
    function clampLt(uint256 a, uint256 b) public returns (uint256) {
        return clampLt(a, b);
    }

    /// @notice int256 version of clampLt
    function clampLt(int256 a, int256 b) public returns (int256) {
        return clampLt(a, b, true);
    }

    /// @notice clamps a to be less than or equal to b
    function clampLte(uint256 a, uint256 b) public returns (uint256) {
        return clampLte(a, b, true);
    }

    /// @notice int256 version of clampLte
    function clampLte(int256 a, int256 b) public returns (int256) {
        return clampLte(a, b, true);
    }

    /// @notice clamps a to be greater than b
    function clampGt(uint256 a, uint256 b) public returns (uint256) {
        return clampGt(a, b, true);
    }

    /// @notice int256 version of clampGt
    function clampGt(int256 a, int256 b) public returns (int256) {
        return clampGt(a, b, true);
    }

    /// @notice clamps a to be greater than or equal to b
    function clampGte(uint256 a, uint256 b) public returns (uint256) {
        return clampGte(a, b, true);
    }

    /// @notice int256 version of clampGte
    function clampGte(int256 a, int256 b) public returns (int256) {
        return clampGte(a, b, true);
    }

    /*
     **************************************************************************
     * Clamp functions with optional logging
     **************************************************************************
     */

    /// @notice Clamps value to be between low and high, both inclusive
    function clamp(
        uint256 value,
        uint256 low,
        uint256 high,
        bool enableLogs
    ) public returns (uint256) {
        if (value < low || value > high) {
            uint256 ans = low + (value % (high - low + 1));
            if (enableLogs) {
                string memory valueStr = FuzzLibString.toString(value);
                string memory ansStr = FuzzLibString.toString(ans);
                bytes memory message = abi.encodePacked(
                    "Clamping value ",
                    valueStr,
                    " to ",
                    ansStr
                );
                emit Clamped(string(message));
            }
            return ans;
        }
        return value;
    }

    /// @notice int256 version of clamp
    function clamp(
        int256 value,
        int256 low,
        int256 high,
        bool enableLogs
    ) public returns (int256) {
        if (value < low || value > high) {
            int256 range = high - low + 1;
            int256 clamped = (value - low) % (range);
            if (clamped < 0) clamped += range;
            int256 ans = low + clamped;
            if (enableLogs) {
                string memory valueStr = FuzzLibString.toString(value);
                string memory ansStr = FuzzLibString.toString(ans);
                bytes memory message = abi.encodePacked(
                    "Clamping value ",
                    valueStr,
                    " to ",
                    ansStr
                );
                emit Clamped(string(message));
            }
            return ans;
        }
        return value;
    }

    /// @notice clamps a to be less than b
    function clampLt(
        uint256 a,
        uint256 b,
        bool enableLogs
    ) public returns (uint256) {
        if (!(a < b)) {
            neq(
                b,
                0,
                "clampLt cannot clamp value a to be less than zero. Check your inputs/assumptions."
            );
            uint256 value = a % b;
            if (enableLogs) {
                string memory aStr = FuzzLibString.toString(a);
                string memory valueStr = FuzzLibString.toString(value);
                bytes memory message = abi.encodePacked(
                    "Clamping value ",
                    aStr,
                    " to ",
                    valueStr
                );
                emit Clamped(string(message));
            }
            return value;
        }
        return a;
    }

    /// @notice int256 version of clampLt
    function clampLt(
        int256 a,
        int256 b,
        bool enableLogs
    ) public returns (int256) {
        if (!(a < b)) {
            int256 value = b - 1;
            if (enableLogs) {
                string memory aStr = FuzzLibString.toString(a);
                string memory valueStr = FuzzLibString.toString(value);
                bytes memory message = abi.encodePacked(
                    "Clamping value ",
                    aStr,
                    " to ",
                    valueStr
                );
                emit Clamped(string(message));
            }
            return value;
        }
        return a;
    }

    /// @notice clamps a to be less than or equal to b
    function clampLte(
        uint256 a,
        uint256 b,
        bool enableLogs
    ) public returns (uint256) {
        if (!(a <= b)) {
            uint256 value = a % (b + 1);
            if (enableLogs) {
                string memory aStr = FuzzLibString.toString(a);
                string memory valueStr = FuzzLibString.toString(value);
                bytes memory message = abi.encodePacked(
                    "Clamping value ",
                    aStr,
                    " to ",
                    valueStr
                );
                emit Clamped(string(message));
            }
            return value;
        }
        return a;
    }

    /// @notice int256 version of clampLte
    function clampLte(
        int256 a,
        int256 b,
        bool enableLogs
    ) public returns (int256) {
        if (!(a <= b)) {
            int256 value = b;
            if (enableLogs) {
                string memory aStr = FuzzLibString.toString(a);
                string memory valueStr = FuzzLibString.toString(value);
                bytes memory message = abi.encodePacked(
                    "Clamping value ",
                    aStr,
                    " to ",
                    valueStr
                );
                emit Clamped(string(message));
            }
            return value;
        }
        return a;
    }

    /// @notice clamps a to be greater than b
    function clampGt(
        uint256 a,
        uint256 b,
        bool enableLogs
    ) public returns (uint256) {
        if (!(a > b)) {
            neq(
                b,
                type(uint256).max,
                "clampGt cannot clamp value a to be larger than uint256.max. Check your inputs/assumptions."
            );
            uint256 value = b + 1;
            if (enableLogs) {
                string memory aStr = FuzzLibString.toString(a);
                string memory valueStr = FuzzLibString.toString(value);
                bytes memory message = abi.encodePacked(
                    "Clamping value ",
                    aStr,
                    " to ",
                    valueStr
                );
                emit Clamped(string(message));
            }
            return value;
        } else {
            return a;
        }
    }

    /// @notice int256 version of clampGt
    function clampGt(
        int256 a,
        int256 b,
        bool enableLogs
    ) public returns (int256) {
        if (!(a > b)) {
            int256 value = b + 1;
            if (enableLogs) {
                string memory aStr = FuzzLibString.toString(a);
                string memory valueStr = FuzzLibString.toString(value);
                bytes memory message = abi.encodePacked(
                    "Clamping value ",
                    aStr,
                    " to ",
                    valueStr
                );
                emit Clamped(string(message));
            }
            return value;
        } else {
            return a;
        }
    }

    /// @notice clamps a to be greater than or equal to b
    function clampGte(
        uint256 a,
        uint256 b,
        bool enableLogs
    ) public returns (uint256) {
        if (!(a > b)) {
            uint256 value = b;
            if (enableLogs) {
                string memory aStr = FuzzLibString.toString(a);
                string memory valueStr = FuzzLibString.toString(value);
                bytes memory message = abi.encodePacked(
                    "Clamping value ",
                    aStr,
                    " to ",
                    valueStr
                );
                emit Clamped(string(message));
            }
            return value;
        }
        return a;
    }

    /// @notice int256 version of clampGte
    function clampGte(
        int256 a,
        int256 b,
        bool enableLogs
    ) public returns (int256) {
        if (!(a > b)) {
            int256 value = b;
            if (enableLogs) {
                string memory aStr = FuzzLibString.toString(a);
                string memory valueStr = FuzzLibString.toString(value);
                bytes memory message = abi.encodePacked(
                    "Clamping value ",
                    aStr,
                    " to ",
                    valueStr
                );
                emit Clamped(string(message));
            }
            return value;
        }
        return a;
    }
}


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {LibLog} from "../libraries/LibLog.sol";

abstract contract HelperLog {
    function log(string memory message) public {
        LibLog.log(message);
    }

    function log(string memory message, string memory data) public {
        LibLog.log(message, data);
    }

    function log(string memory message, bytes memory data) public {
        LibLog.log(message, data);
    }

    function log(string memory message, uint256 data) public {
        LibLog.log(message, data);
    }

    function log(string memory message, int256 data) public {
        LibLog.log(message, data);
    }

    function log(string memory message, address data) public {
        LibLog.log(message, data);
    }

    function log(string memory message, bool data) public {
        LibLog.log(message, data);
    }

    function log(string memory message, bytes32 data) public {
        LibLog.log(message, data);
    }

    function logFail() public {
        LibLog.logFail();
    }

    function logFail(string memory message) public {
        LibLog.logFail(message);
    }

    function logFail(string memory message, string memory data) public {
        LibLog.logFail(message, data);
    }

    function logFail(string memory message, bytes memory data) public {
        LibLog.logFail(message, data);
    }

    function logFail(string memory message, uint256 data) public {
        LibLog.logFail(message, data);
    }

    function logFail(string memory message, int256 data) public {
        LibLog.logFail(message, data);
    }

    function logFail(string memory message, address data) public {
        LibLog.logFail(message, data);
    }

    function logFail(string memory message, bool data) public {
        LibLog.logFail(message, data);
    }

    function logFail(string memory message, bytes32 data) public {
        LibLog.log(message, data);
    }
}


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

abstract contract HelperMath {
    function min(uint256 a, uint256 b) public pure returns (uint256) {
        return a < b ? a : b;
    }

    function max(uint256 a, uint256 b) public pure returns (uint256) {
        return a > b ? a : b;
    }

    // Forked from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.0.0/contracts/utils/math/SignedMath.sol
    function max(int256 a, int256 b) public pure returns (int256) {
        return a > b ? a : b;
    }

    // Forked with modifications from https://ethereum.stackexchange.com/a/84391
    function abs(int128 n) public pure returns (int128) {
        return n >= 0 ? n : -n;
    }

    function abs(int256 n) public pure returns (uint256) {
        return n >= 0 ? uint256(n) : uint256(-n);
    }

    function diff(int256 a, int256 b) public pure returns (uint256) {
        return a >= b ? uint256(a - b) : uint256(b - a);
    }

    function diff(uint256 a, uint256 b) public pure returns (uint256) {
        return a >= b ? a - b : b - a;
    }
}


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

abstract contract HelperRandom {
    /// @notice Shuffle an array using Fisher-Yates algorithm
    /// @dev Based on https://gist.github.com/scammi/602387a22e04c77beb73c0ebc0f0bc18
    function shuffleArray(
        uint256[] memory shuffle,
        uint256 entropy
    ) public pure {
        for (uint256 i = shuffle.length - 1; i > 0; i--) {
            uint256 swapIndex = entropy % (shuffle.length - i);

            uint256 currentIndex = shuffle[i];
            uint256 indexToSwap = shuffle[swapIndex];

            shuffle[i] = indexToSwap;
            shuffle[swapIndex] = currentIndex;
        }
    }
}


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

library LibLog {
    event Log(string message);
    event LogString(string message, string data);
    event LogBytes(string message, bytes data);
    event LogUint(string message, uint256 data);
    event LogInt(string message, int256 data);
    event LogAddress(string message, address data);
    event LogBool(string message, bool data);
    event LogBytes32(string message, bytes32 data);

    event AssertionFailed();
    event AssertionFailed(string message);
    event AssertionFailed(string message, string data);
    event AssertionFailed(string message, bytes data);
    event AssertionFailed(string message, uint256 data);
    event AssertionFailed(string message, int256 data);
    event AssertionFailed(string message, address data);
    event AssertionFailed(string message, bool data);

    function log(string memory message) internal {
        emit Log(message);
    }

    function log(string memory message, string memory data) internal {
        emit LogString(message, data);
    }

    function log(string memory message, bytes memory data) internal {
        emit LogBytes(message, data);
    }

    function log(string memory message, uint256 data) internal {
        emit LogUint(message, data);
    }

    function log(string memory message, int256 data) internal {
        emit LogInt(message, data);
    }

    function log(string memory message, address data) internal {
        emit LogAddress(message, data);
    }

    function log(string memory message, bool data) internal {
        emit LogBool(message, data);
    }

    function log(string memory message, bytes32 data) internal {
        emit LogBytes32(message, data);
    }

    function logFail() internal {
        emit AssertionFailed();
    }

    function logFail(string memory message) internal {
        emit AssertionFailed(message);
    }

    function logFail(string memory message, string memory data) internal {
        emit AssertionFailed(message, data);
    }

    function logFail(string memory message, bytes memory data) internal {
        emit AssertionFailed(message, data);
    }

    function logFail(string memory message, uint256 data) internal {
        emit AssertionFailed(message, data);
    }

    function logFail(string memory message, int256 data) internal {
        emit AssertionFailed(message, data);
    }

    function logFail(string memory message, address data) internal {
        emit AssertionFailed(message, data);
    }

    function logFail(string memory message, bool data) internal {
        emit AssertionFailed(message, data);
    }

    function logFail(string memory message, bytes32 data) internal {
        emit LogBytes32(message, data);
    }
}


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface IPlatform {
    function assertFail() pure external;
}



// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {IPlatform} from "./IPlatform.sol";

contract PlatformCrytic is IPlatform {
    function assertFail() pure public override{
        assert(false);
    }
}


The `FuzzBase` contract is an abstract contract that initializes an instance of the `Fuzzlib` library and sets its platform to a new instance of the `PlatformCrytic` contract. This setup is done in the constructor, ensuring that any contract inheriting `FuzzBase` will have access to the `Fuzzlib` instance configured with the `PlatformCrytic` platform.