{
    "Function": "slitherConstructorConstantVariables",
    "File": "contracts/lib/solady/test/utils/TestPlus.sol",
    "Parent Contracts": [],
    "High-Level Calls": [],
    "Internal Calls": [],
    "Library Calls": [],
    "Low-Level Calls": [],
    "Code": "contract TestPlus {\n    /// @dev `address(bytes20(uint160(uint256(keccak256(\"hevm cheat code\")))))`.\n    address private constant _VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;\n\n    /// @dev Fills the memory with junk, for more robust testing of inline assembly\n    /// which reads/write to the memory.\n    function _brutalizeMemory() private view {\n        // To prevent a solidity 0.8.13 bug.\n        // See: https://blog.soliditylang.org/2022/06/15/inline-assembly-memory-side-effects-bug\n        // Basically, we need to access a solidity variable from the assembly to\n        // tell the compiler that this assembly block is not in isolation.\n        uint256 zero;\n        /// @solidity memory-safe-assembly\n        assembly {\n            let offset := mload(0x40) // Start the offset at the free memory pointer.\n            calldatacopy(offset, zero, calldatasize())\n\n            // Fill the 64 bytes of scratch space with garbage.\n            mstore(zero, add(caller(), gas()))\n            mstore(0x20, keccak256(offset, calldatasize()))\n            mstore(zero, keccak256(zero, 0x40))\n\n            let r0 := mload(zero)\n            let r1 := mload(0x20)\n\n            let cSize := add(codesize(), iszero(codesize()))\n            if iszero(lt(cSize, 32)) { cSize := sub(cSize, and(mload(0x02), 0x1f)) }\n            let start := mod(mload(0x10), cSize)\n            let size := mul(sub(cSize, start), gt(cSize, start))\n            let times := div(0x7ffff, cSize)\n            if iszero(lt(times, 128)) { times := 128 }\n\n            // Occasionally offset the offset by a pseudorandom large amount.\n            // Can't be too large, or we will easily get out-of-gas errors.\n            offset := add(offset, mul(iszero(and(r1, 0xf)), and(r0, 0xfffff)))\n\n            // Fill the free memory with garbage.\n            // prettier-ignore\n            for { let w := not(0) } 1 {} {\n                mstore(offset, r0)\n                mstore(add(offset, 0x20), r1)\n                offset := add(offset, 0x40)\n                // We use codecopy instead of the identity precompile\n                // to avoid polluting the `forge test -vvvv` output with tons of junk.\n                codecopy(offset, start, size)\n                codecopy(add(offset, size), 0, start)\n                offset := add(offset, cSize)\n                times := add(times, w) // `sub(times, 1)`.\n                if iszero(times) { break }\n            }\n        }\n    }\n\n    /// @dev Fills the memory with junk, for more robust testing of inline assembly\n    /// which reads/write to the memory.\n    modifier brutalizeMemory() {\n        _brutalizeMemory();\n        _;\n        _checkMemory();\n    }\n\n    /// @dev Returns a pseudorandom random number from [0 .. 2**256 - 1] (inclusive).\n    /// For usage in fuzz tests, please ensure that the function has an unnamed uint256 argument.\n    /// e.g. `testSomething(uint256) public`.\n    function _random() internal returns (uint256 r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // This is the keccak256 of a very long string I randomly mashed on my keyboard.\n            let sSlot := 0xd715531fe383f818c5f158c342925dcf01b954d24678ada4d07c36af0f20e1ee\n            let sValue := sload(sSlot)\n\n            mstore(0x20, sValue)\n            r := keccak256(0x20, 0x40)\n\n            // If the storage is uninitialized, initialize it to the keccak256 of the calldata.\n            if iszero(sValue) {\n                sValue := sSlot\n                let m := mload(0x40)\n                calldatacopy(m, 0, calldatasize())\n                r := keccak256(m, calldatasize())\n            }\n            sstore(sSlot, add(r, 1))\n\n            // Do some biased sampling for more robust tests.\n            // prettier-ignore\n            for {} 1 {} {\n                let d := byte(0, r)\n                // With a 1/256 chance, randomly set `r` to any of 0,1,2.\n                if iszero(d) {\n                    r := and(r, 3)\n                    break\n                }\n                // With a 1/2 chance, set `r` to near a random power of 2.\n                if iszero(and(2, d)) {\n                    // Set `t` either `not(0)` or `xor(sValue, r)`.\n                    let t := xor(not(0), mul(iszero(and(4, d)), not(xor(sValue, r))))\n                    // Set `r` to `t` shifted left or right by a random multiple of 8.\n                    switch and(8, d)\n                    case 0 {\n                        if iszero(and(16, d)) { t := 1 }\n                        r := add(shl(shl(3, and(byte(3, r), 0x1f)), t), sub(and(r, 7), 3))\n                    }\n                    default {\n                        if iszero(and(16, d)) { t := shl(255, 1) }\n                        r := add(shr(shl(3, and(byte(3, r), 0x1f)), t), sub(and(r, 7), 3))\n                    }\n                    // With a 1/2 chance, negate `r`.\n                    if iszero(and(0x20, d)) { r := not(r) }\n                    break\n                }\n                // Otherwise, just set `r` to `xor(sValue, r)`.\n                r := xor(sValue, r)\n                break\n            }\n        }\n    }\n\n    /// @dev Returns a random signer and its private key.\n    function _randomSigner() internal returns (address signer, uint256 privateKey) {\n        uint256 privateKeyMax = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140;\n        privateKey = _hem(_random(), 1, privateKeyMax);\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0xffa18649) // `addr(uint256)`.\n            mstore(0x20, privateKey)\n            if iszero(call(gas(), _VM_ADDRESS, 0, 0x1c, 0x24, 0x00, 0x20)) { revert(0, 0) }\n            signer := mload(0x00)\n        }\n    }\n\n    /// @dev Returns a random address.\n    function _randomAddress() internal returns (address result) {\n        result = address(uint160(_random()));\n    }\n\n    /// @dev Returns a random non-zero address.\n    function _randomNonZeroAddress() internal returns (address result) {\n        do {\n            result = address(uint160(_random()));\n        } while (result == address(0));\n    }\n\n    /// @dev Rounds up the free memory pointer the the next word boundary.\n    /// Sometimes, some Solidity operations causes the free memory pointer to be misaligned.\n    function _roundUpFreeMemoryPointer() internal pure {\n        // To prevent a solidity 0.8.13 bug.\n        // See: https://blog.soliditylang.org/2022/06/15/inline-assembly-memory-side-effects-bug\n        // Basically, we need to access a solidity variable from the assembly to\n        // tell the compiler that this assembly block is not in isolation.\n        uint256 twoWords = 0x40;\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(twoWords, and(add(mload(twoWords), 0x1f), not(0x1f)))\n        }\n    }\n\n    /// @dev Misaligns the free memory pointer.\n    /// The free memory pointer has a 1/32 chance to be aligned.\n    function _misalignFreeMemoryPointer() internal pure {\n        uint256 twoWords = 0x40;\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(twoWords)\n            m := add(m, mul(and(keccak256(0x00, twoWords), 0x1f), iszero(and(m, 0x1f))))\n            mstore(twoWords, m)\n        }\n    }\n\n    /// @dev Check if the free memory pointer and the zero slot are not contaminated.\n    /// Useful for cases where these slots are used for temporary storage.\n    function _checkMemory() internal pure {\n        bool zeroSlotIsNotZero;\n        bool freeMemoryPointerOverflowed;\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Write ones to the free memory, to make subsequent checks fail if\n            // insufficient memory is allocated.\n            mstore(mload(0x40), not(0))\n            // Test at a lower, but reasonable limit for more safety room.\n            if gt(mload(0x40), 0xffffffff) { freeMemoryPointerOverflowed := 1 }\n            // Check the value of the zero slot.\n            zeroSlotIsNotZero := mload(0x60)\n        }\n        if (freeMemoryPointerOverflowed) revert(\"`0x40` overflowed!\");\n        if (zeroSlotIsNotZero) revert(\"`0x60` is not zero!\");\n    }\n\n    /// @dev Check if `s`:\n    /// - Has sufficient memory allocated.\n    /// - Is zero right padded (cuz some frontends like Etherscan has issues\n    ///   with decoding non-zero-right-padded strings).\n    function _checkMemory(bytes memory s) internal pure {\n        bool notZeroRightPadded;\n        bool insufficientMalloc;\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Write ones to the free memory, to make subsequent checks fail if\n            // insufficient memory is allocated.\n            mstore(mload(0x40), not(0))\n            let length := mload(s)\n            let lastWord := mload(add(add(s, 0x20), and(length, not(0x1f))))\n            let remainder := and(length, 0x1f)\n            if remainder { if shl(mul(8, remainder), lastWord) { notZeroRightPadded := 1 } }\n            // Check if the memory allocated is sufficient.\n            if length { if gt(add(add(s, 0x20), length), mload(0x40)) { insufficientMalloc := 1 } }\n        }\n        if (notZeroRightPadded) revert(\"Not zero right padded!\");\n        if (insufficientMalloc) revert(\"Insufficient memory allocation!\");\n        _checkMemory();\n    }\n\n    /// @dev For checking the memory allocation for string `s`.\n    function _checkMemory(string memory s) internal pure {\n        _checkMemory(bytes(s));\n    }\n\n    /// @dev Adapted from `bound`:\n    /// https://github.com/foundry-rs/forge-std/blob/ff4bf7db008d096ea5a657f2c20516182252a3ed/src/StdUtils.sol#L10\n    /// Differentially fuzzed tested against the original implementation.\n    function _hem(uint256 x, uint256 min, uint256 max)\n        internal\n        pure\n        virtual\n        returns (uint256 result)\n    {\n        require(min <= max, \"Max is less than min.\");\n\n        /// @solidity memory-safe-assembly\n        assembly {\n            // prettier-ignore\n            for {} 1 {} {\n                // If `x` is between `min` and `max`, return `x` directly.\n                // This is to ensure that dictionary values\n                // do not get shifted if the min is nonzero.\n                // More info: https://github.com/foundry-rs/forge-std/issues/188\n                if iszero(or(lt(x, min), gt(x, max))) {\n                    result := x\n                    break\n                }\n\n                let size := add(sub(max, min), 1)\n                if and(iszero(gt(x, 3)), gt(size, x)) {\n                    result := add(min, x)\n                    break\n                }\n\n                let w := not(0)\n                if and(iszero(lt(x, sub(0, 4))), gt(size, sub(w, x))) {\n                    result := sub(max, sub(w, x))\n                    break\n                }\n\n                // Otherwise, wrap x into the range [min, max],\n                // i.e. the range is inclusive.\n                if iszero(lt(x, max)) {\n                    let d := sub(x, max)\n                    let r := mod(d, size)\n                    if iszero(r) {\n                        result := max\n                        break\n                    }\n                    result := add(add(min, r), w)\n                    break\n                }\n                let d := sub(min, x)\n                let r := mod(d, size)\n                if iszero(r) {\n                    result := min\n                    break\n                }\n                result := add(sub(max, r), 1)\n                break\n            }\n        }\n    }\n\n    /// @dev Deploys a contract via 0age's immutable create 2 factory for testing.\n    function _safeCreate2(uint256 payableAmount, bytes32 salt, bytes memory initializationCode)\n        internal\n        returns (address deploymentAddress)\n    {\n        // Canonical address of 0age's immutable create 2 factory.\n        address c2f = 0x0000000000FFe8B47B3e2130213B802212439497;\n        uint256 c2fCodeLength;\n        /// @solidity memory-safe-assembly\n        assembly {\n            c2fCodeLength := extcodesize(c2f)\n        }\n        if (c2fCodeLength == 0) {\n            bytes memory ic2fBytecode =\n                hex\"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\";\n            /// @solidity memory-safe-assembly\n            assembly {\n                let m := mload(0x40)\n                mstore(m, 0xb4d6c782) // `etch(address,bytes)`.\n                mstore(add(m, 0x20), c2f)\n                mstore(add(m, 0x40), 0x40)\n                let n := mload(ic2fBytecode)\n                mstore(add(m, 0x60), n)\n                for { let i := 0 } lt(i, n) { i := add(0x20, i) } {\n                    mstore(add(add(m, 0x80), i), mload(add(add(ic2fBytecode, 0x20), i)))\n                }\n                if iszero(call(gas(), _VM_ADDRESS, 0, add(m, 0x1c), add(n, 0x64), 0x00, 0x00)) {\n                    revert(0, 0)\n                }\n            }\n        }\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            let n := mload(initializationCode)\n            mstore(m, 0x64e03087) // `safeCreate2(bytes32,bytes)`.\n            mstore(add(m, 0x20), salt)\n            mstore(add(m, 0x40), 0x40)\n            mstore(add(m, 0x60), n)\n            // prettier-ignore\n            for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n                mstore(add(add(m, 0x80), i), mload(add(add(initializationCode, 0x20), i)))\n            }\n            if iszero(call(gas(), c2f, payableAmount, add(m, 0x1c), add(n, 0x64), m, 0x20)) {\n                returndatacopy(m, m, returndatasize())\n                revert(m, returndatasize())\n            }\n            deploymentAddress := mload(m)\n        }\n    }\n\n    /// @dev Deploys a contract via 0age's immutable create 2 factory for testing.\n    function _safeCreate2(bytes32 salt, bytes memory initializationCode)\n        internal\n        returns (address deploymentAddress)\n    {\n        deploymentAddress = _safeCreate2(0, salt, initializationCode);\n    }\n\n    /// @dev This function will make forge's gas output display the approximate codesize of\n    /// the test contract as the amount of gas burnt. Useful for quick guess checking if\n    /// certain optimizations actually compiles to similar bytecode.\n    function test__codesize() external view {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // If the caller is the contract itself (i.e. recursive call), burn all the gas.\n            if eq(caller(), address()) { invalid() }\n            mstore(0x00, 0xf09ff470) // Store the function selector of `test__codesize()`.\n            pop(staticcall(codesize(), address(), 0x1c, 0x04, 0x00, 0x00))\n        }\n    }\n}"
}