From e1d7a2d5b55978d096c26ae5ae647596b1f924ac Mon Sep 17 00:00:00 2001
From: thedavidmeister <thedavidmeister@gmail.com>
Date: Thu, 31 Jul 2025 16:21:40 +0200
Subject: [PATCH 01/10] bump int

---
 lib/rain.interpreter.interface | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/rain.interpreter.interface b/lib/rain.interpreter.interface
index 16288d1b0..335d5165a 160000
--- a/lib/rain.interpreter.interface
+++ b/lib/rain.interpreter.interface
@@ -1 +1 @@
-Subproject commit 16288d1b0e98c9e088963dbcb0b6b89e2e06fbfa
+Subproject commit 335d5165a20f62158c210bfca5e08335a6b6c22a

From 567dbd77bd52a72dcf5b688aaa8f2e852f042cfc Mon Sep 17 00:00:00 2001
From: thedavidmeister <thedavidmeister@gmail.com>
Date: Thu, 31 Jul 2025 17:14:50 +0200
Subject: [PATCH 02/10] max positive value

---
 ...interpreterExpressionDeployer.pointers.sol |  4 +-
 .../RainterpreterParser.pointers.sol          |  4 +-
 src/lib/op/LibAllStandardOps.sol              |  8 ++--
 ...MaxValue.sol => LibOpMaxPositiveValue.sol} |  6 +--
 ...alue.t.sol => LibOpMaxPositiveValue.t.sol} | 47 +++++++++++--------
 5 files changed, 38 insertions(+), 31 deletions(-)
 rename src/lib/op/math/{LibOpMaxValue.sol => LibOpMaxPositiveValue.sol} (91%)
 rename test/src/lib/op/math/{LibOpMaxValue.t.sol => LibOpMaxPositiveValue.t.sol} (54%)

diff --git a/src/generated/RainterpreterExpressionDeployer.pointers.sol b/src/generated/RainterpreterExpressionDeployer.pointers.sol
index 4b59d5e69..54dc8d329 100644
--- a/src/generated/RainterpreterExpressionDeployer.pointers.sol
+++ b/src/generated/RainterpreterExpressionDeployer.pointers.sol
@@ -10,10 +10,10 @@
 pragma solidity =0.8.25;
 
 /// @dev Hash of the known bytecode.
-bytes32 constant BYTECODE_HASH = bytes32(0xedc85dfac63f4681b2d5ffb348c7796f7a3fdbe6de22aab8244b0bade2783426);
+bytes32 constant BYTECODE_HASH = bytes32(0xb93b87f9f42b5dc511db227ae7dbfd7745c0f8289e2a378d49213497b2d51f0a);
 
 /// @dev The hash of the meta that describes the contract.
-bytes32 constant DESCRIBED_BY_META_HASH = bytes32(0x71a0d06f6c91b15436b0558882e812cfeabb78c20dc1490287a2a0d59541ef4b);
+bytes32 constant DESCRIBED_BY_META_HASH = bytes32(0x6c6680fa8762cdadcdd54d41f8ca715b0a5bca0660c386fb066ecac29180a8c8);
 
 /// @dev The function pointers for the integrity check fns.
 bytes constant INTEGRITY_FUNCTION_POINTERS =
diff --git a/src/generated/RainterpreterParser.pointers.sol b/src/generated/RainterpreterParser.pointers.sol
index 9b07377c7..f2dea8529 100644
--- a/src/generated/RainterpreterParser.pointers.sol
+++ b/src/generated/RainterpreterParser.pointers.sol
@@ -10,7 +10,7 @@
 pragma solidity =0.8.25;
 
 /// @dev Hash of the known bytecode.
-bytes32 constant BYTECODE_HASH = bytes32(0xf5b705e7eaebf246c1a369b2dfc297bd3023ddedb809a4733e0966f3398e4332);
+bytes32 constant BYTECODE_HASH = bytes32(0xdc90ebffd65fcf8a93f4941f19a7856ba92460fa75b3b7969e0618a68eb2e30d);
 
 /// @dev The parse meta that is used to lookup word definitions.
 /// The structure of the parse meta is:
@@ -29,7 +29,7 @@ bytes32 constant BYTECODE_HASH = bytes32(0xf5b705e7eaebf246c1a369b2dfc297bd3023d
 /// bit count of the previous bloom filter. If we reach the end of the bloom
 /// filters then we have a miss.
 bytes constant PARSE_META =
-    hex"027d32482901a416101c2a01b8024080020111206043108201222060060071004a8800000000000000000800200000000000000000000000000000000000000000000034ee31ff1e4c42622cd999cd146aa9391a378a701bca041513bfc04d2dd959ad31ac0034053824512b8fb9fe39530a92378e9cbd1096c4d004ea67600a2aa235194d56371c05a7650cd5a68e233f227012f1ac932480073416d4a5b3159bd3ec068483ae35f6dc5d27f0c0a632a6feff219677b933db58d401d4fa88030cae020885d59f368413023067b4531d4070aa1fc9b66f2540ab0f2a5a53d8115fb3680ff7e328293977d317686f5c3abd3f5f024641b928630c0709f14a300b1ec71b2fa3832322792a603b5d96b73d7b8cf22653f8d13c33bccc0d403ded0791b7eb002ddffc0e1abd702ece1fe238f61a8018beccb0204507bb";
+    hex"02192a4782060c081806c6c1900010012220200283041069040114680901208401260000000000000000000000000000000000000000001000000000000000000000202c49b09d200441910d1e98a7329c08461fd6ea18118eba9713065d3029ab10ec04ac72c00e7ff5a23dae0c8706fb9c253cc7bc2333acb2941b0b5fc712fec72838112cee18d295ed35d9a6c50063d58d34dd44c9261df07b012ba09831d9776c0c6cbb422f6d6b2403ae6396082c4e962787daec2841d78a16172ab51a5b8f1d1c2d57c43aca85c615f871180f48502f25b9d38d0be7f2e71ef1ff4d19d140c23b1a1e3510abcc6405b702d7020f038b2a93067d220df2ef07ee624a214143471482e75b1d60aa350a3d21ff174c80cb30cc4a6a39023c042ba9578e360cdb6909a046dc2ed4e3cf233bc325379b388724b25e682d7b09ff";
 
 /// @dev The build depth of the parser meta.
 
diff --git a/src/lib/op/LibAllStandardOps.sol b/src/lib/op/LibAllStandardOps.sol
index cc92051fd..371f02f73 100644
--- a/src/lib/op/LibAllStandardOps.sol
+++ b/src/lib/op/LibAllStandardOps.sol
@@ -86,7 +86,7 @@ import {LibOpInv} from "./math/LibOpInv.sol";
 // import {LibOpLn} from "./math/LibOpLn.sol";
 // import {LibOpLog10} from "./math/LibOpLog10.sol";
 import {LibOpMax} from "./math/LibOpMax.sol";
-import {LibOpMaxValue} from "./math/LibOpMaxValue.sol";
+import {LibOpMaxPositiveValue} from "./math/LibOpMaxPositiveValue.sol";
 import {LibOpMin} from "./math/LibOpMin.sol";
 import {LibOpMinValue} from "./math/LibOpMinValue.sol";
 import {LibOpMod} from "./math/LibOpMod.sol";
@@ -286,7 +286,7 @@ library LibAllStandardOps {
             // AuthoringMetaV2("log10", "Base 10 logarithm log10(x). Errors if the number is zero."),
             AuthoringMetaV2("max", "Finds the maximum number from all inputs."),
             AuthoringMetaV2(
-                "max-value",
+                "max-positive-value",
                 "The maximum representable float value. This is so large that it is effectively infinity. Almost all numbers that you could possibly subtract from it will be ignored as a rounding error."
             ),
             AuthoringMetaV2("min", "Finds the minimum number from all inputs."),
@@ -601,7 +601,7 @@ library LibAllStandardOps {
                     // LibOpLog2.integrity,
                     // LibOpLog10.integrity,
                     LibOpMax.integrity,
-                    LibOpMaxValue.integrity,
+                    LibOpMaxPositiveValue.integrity,
                     LibOpMin.integrity,
                     LibOpMinValue.integrity,
                     // LibOpMod.integrity,
@@ -710,7 +710,7 @@ library LibAllStandardOps {
                     // LibOpLog2.run,
                     // LibOpLog10.run,
                     LibOpMax.run,
-                    LibOpMaxValue.run,
+                    LibOpMaxPositiveValue.run,
                     LibOpMin.run,
                     LibOpMinValue.run,
                     // LibOpMod.run,
diff --git a/src/lib/op/math/LibOpMaxValue.sol b/src/lib/op/math/LibOpMaxPositiveValue.sol
similarity index 91%
rename from src/lib/op/math/LibOpMaxValue.sol
rename to src/lib/op/math/LibOpMaxPositiveValue.sol
index 8b23c9f31..a3ac91e8b 100644
--- a/src/lib/op/math/LibOpMaxValue.sol
+++ b/src/lib/op/math/LibOpMaxPositiveValue.sol
@@ -7,9 +7,9 @@ import {InterpreterState} from "../../state/LibInterpreterState.sol";
 import {Pointer} from "rain.solmem/lib/LibPointer.sol";
 import {Float, LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol";
 
-/// @title LibOpMaxValue
+/// @title LibOpMaxPositiveValue
 /// Exposes the maximum representable float value as a Rainlang opcode.
-library LibOpMaxValue {
+library LibOpMaxPositiveValue {
     using LibDecimalFloat for Float;
 
     function integrity(IntegrityCheckState memory, OperandV2) internal pure returns (uint256, uint256) {
@@ -17,7 +17,7 @@ library LibOpMaxValue {
     }
 
     function run(InterpreterState memory, OperandV2, Pointer stackTop) internal pure returns (Pointer) {
-        Float value = LibDecimalFloat.FLOAT_MAX_VALUE;
+        Float value = LibDecimalFloat.FLOAT_MAX_POSITIVE_VALUE;
         assembly ("memory-safe") {
             stackTop := sub(stackTop, 0x20)
             mstore(stackTop, value)
diff --git a/test/src/lib/op/math/LibOpMaxValue.t.sol b/test/src/lib/op/math/LibOpMaxPositiveValue.t.sol
similarity index 54%
rename from test/src/lib/op/math/LibOpMaxValue.t.sol
rename to test/src/lib/op/math/LibOpMaxPositiveValue.t.sol
index ff4bf80d1..85fafe861 100644
--- a/test/src/lib/op/math/LibOpMaxValue.t.sol
+++ b/test/src/lib/op/math/LibOpMaxPositiveValue.t.sol
@@ -2,7 +2,7 @@
 pragma solidity =0.8.25;
 
 import {OpTest} from "test/abstract/OpTest.sol";
-import {LibOpMaxValue} from "src/lib/op/math/LibOpMaxValue.sol";
+import {LibOpMaxPositiveValue} from "src/lib/op/math/LibOpMaxPositiveValue.sol";
 import {IntegrityCheckState, BadOpInputsLength} from "src/lib/integrity/LibIntegrityCheck.sol";
 import {
     IInterpreterV4,
@@ -18,13 +18,13 @@ import {SignedContextV1} from "rain.interpreter.interface/interface/IInterpreter
 import {LibOperand} from "test/lib/operand/LibOperand.sol";
 import {Float, LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol";
 
-/// @title LibOpMaxValueTest
-/// @notice Test the runtime and integrity time logic of LibOpMaxValue.
-contract LibOpMaxValueTest is OpTest {
+/// @title LibOpMaxPositiveValueTest
+/// @notice Test the runtime and integrity time logic of LibOpMaxPositiveValue.
+contract LibOpMaxPositiveValueTest is OpTest {
     using LibInterpreterState for InterpreterState;
     using LibDecimalFloat for Float;
 
-    /// Directly test the integrity logic of LibOpMaxValue.
+    /// Directly test the integrity logic of LibOpMaxPositiveValue.
     function testOpMaxValueIntegrity(IntegrityCheckState memory state, uint8 inputs, uint8 outputs, uint16 operandData)
         external
         pure
@@ -32,38 +32,45 @@ contract LibOpMaxValueTest is OpTest {
         inputs = uint8(bound(inputs, 0, 0x0F));
         outputs = uint8(bound(outputs, 0, 0x0F));
         (uint256 calcInputs, uint256 calcOutputs) =
-            LibOpMaxValue.integrity(state, LibOperand.build(inputs, outputs, operandData));
+            LibOpMaxPositiveValue.integrity(state, LibOperand.build(inputs, outputs, operandData));
 
         assertEq(calcInputs, 0);
         assertEq(calcOutputs, 1);
     }
 
-    /// Directly test the runtime logic of LibOpMaxValue. This tests that the
-    /// opcode correctly pushes the max value onto the stack.
-    function testOpMaxValueRun() external view {
+    /// Directly test the runtime logic of LibOpMaxPositiveValue. This tests that
+    /// the opcode correctly pushes the max value onto the stack.
+    function testOpMaxPositiveValueRun() external view {
         InterpreterState memory state = opTestDefaultInterpreterState();
         StackItem[] memory inputs = new StackItem[](0);
         OperandV2 operand = LibOperand.build(0, 1, 0);
-        opReferenceCheck(state, operand, LibOpMaxValue.referenceFn, LibOpMaxValue.integrity, LibOpMaxValue.run, inputs);
+        opReferenceCheck(
+            state,
+            operand,
+            LibOpMaxPositiveValue.referenceFn,
+            LibOpMaxPositiveValue.integrity,
+            LibOpMaxPositiveValue.run,
+            inputs
+        );
     }
 
-    /// Test the eval of LibOpMaxValue parsed from a string.
-    function testOpMaxValueEval() external view {
-        checkHappy("_: max-value();", Float.unwrap(LibDecimalFloat.FLOAT_MAX_VALUE), "");
+    /// Test the eval of LibOpMaxPositiveValue parsed from a string.
+    function testOpMaxPositivepValueEval() external view {
+        checkHappy("_: max-positive-value();", Float.unwrap(LibDecimalFloat.FLOAT_MAX_POSITIVE_VALUE), "");
     }
 
-    /// Test that a max-value with inputs fails integrity check.
-    function testOpMaxValueEvalFail() public {
+    /// Test that a max-positive-value with inputs fails integrity check.
+    function testOpMaxPositiveValueEvalFail() public {
         vm.expectRevert(abi.encodeWithSelector(BadOpInputsLength.selector, 1, 0, 1));
-        bytes memory bytecode = iDeployer.parse2("_: max-value(0x00);");
+        bytes memory bytecode = iDeployer.parse2("_: max-positive-value(0x00);");
         (bytecode);
     }
 
-    function testOpMaxValueZeroOutputs() external {
-        checkBadOutputs(": max-value();", 0, 1, 0);
+    function testOpMaxPositiveValueZeroOutputs() external {
+        checkBadOutputs(": max-positive-value();", 0, 1, 0);
     }
 
-    function testOpMaxValueTwoOutputs() external {
-        checkBadOutputs("_ _: max-value();", 0, 1, 2);
+    function testOpMaxPositiveValueTwoOutputs() external {
+        checkBadOutputs("_ _: max-positive-value();", 0, 1, 2);
     }
 }

From 223957063fd8452dfb7607f949cd3b9cea87c6e5 Mon Sep 17 00:00:00 2001
From: thedavidmeister <thedavidmeister@gmail.com>
Date: Thu, 31 Jul 2025 17:25:47 +0200
Subject: [PATCH 03/10] min neg value

---
 ...interpreterExpressionDeployer.pointers.sol |  4 +-
 .../RainterpreterParser.pointers.sol          |  4 +-
 src/lib/op/LibAllStandardOps.sol              |  8 +-
 ...MinValue.sol => LibOpMinNegativeValue.sol} |  4 +-
 .../lib/op/math/LibOpMinNegativeValue.t.sol   | 78 +++++++++++++++++++
 test/src/lib/op/math/LibOpMinValue.t.sol      | 69 ----------------
 6 files changed, 88 insertions(+), 79 deletions(-)
 rename src/lib/op/math/{LibOpMinValue.sol => LibOpMinNegativeValue.sol} (95%)
 create mode 100644 test/src/lib/op/math/LibOpMinNegativeValue.t.sol
 delete mode 100644 test/src/lib/op/math/LibOpMinValue.t.sol

diff --git a/src/generated/RainterpreterExpressionDeployer.pointers.sol b/src/generated/RainterpreterExpressionDeployer.pointers.sol
index 54dc8d329..3bf151231 100644
--- a/src/generated/RainterpreterExpressionDeployer.pointers.sol
+++ b/src/generated/RainterpreterExpressionDeployer.pointers.sol
@@ -10,10 +10,10 @@
 pragma solidity =0.8.25;
 
 /// @dev Hash of the known bytecode.
-bytes32 constant BYTECODE_HASH = bytes32(0xb93b87f9f42b5dc511db227ae7dbfd7745c0f8289e2a378d49213497b2d51f0a);
+bytes32 constant BYTECODE_HASH = bytes32(0x8871204333d6734d793a9137148e2948b21603ba2e20e3c6cf13274899693a4a);
 
 /// @dev The hash of the meta that describes the contract.
-bytes32 constant DESCRIBED_BY_META_HASH = bytes32(0x6c6680fa8762cdadcdd54d41f8ca715b0a5bca0660c386fb066ecac29180a8c8);
+bytes32 constant DESCRIBED_BY_META_HASH = bytes32(0x5de1339cce4dd247ad995d5aaf0c2d18cfefdc73fd51217a6f281e76d60a9162);
 
 /// @dev The function pointers for the integrity check fns.
 bytes constant INTEGRITY_FUNCTION_POINTERS =
diff --git a/src/generated/RainterpreterParser.pointers.sol b/src/generated/RainterpreterParser.pointers.sol
index f2dea8529..5ef1f56da 100644
--- a/src/generated/RainterpreterParser.pointers.sol
+++ b/src/generated/RainterpreterParser.pointers.sol
@@ -10,7 +10,7 @@
 pragma solidity =0.8.25;
 
 /// @dev Hash of the known bytecode.
-bytes32 constant BYTECODE_HASH = bytes32(0xdc90ebffd65fcf8a93f4941f19a7856ba92460fa75b3b7969e0618a68eb2e30d);
+bytes32 constant BYTECODE_HASH = bytes32(0x8f567366178330788b7901a60e89ed3de53a4e8c436005de92d56db72e2a79c9);
 
 /// @dev The parse meta that is used to lookup word definitions.
 /// The structure of the parse meta is:
@@ -29,7 +29,7 @@ bytes32 constant BYTECODE_HASH = bytes32(0xdc90ebffd65fcf8a93f4941f19a7856ba9246
 /// bit count of the previous bloom filter. If we reach the end of the bloom
 /// filters then we have a miss.
 bytes constant PARSE_META =
-    hex"02192a4782060c081806c6c1900010012220200283041069040114680901208401260000000000000000000000000000000000000000001000000000000000000000202c49b09d200441910d1e98a7329c08461fd6ea18118eba9713065d3029ab10ec04ac72c00e7ff5a23dae0c8706fb9c253cc7bc2333acb2941b0b5fc712fec72838112cee18d295ed35d9a6c50063d58d34dd44c9261df07b012ba09831d9776c0c6cbb422f6d6b2403ae6396082c4e962787daec2841d78a16172ab51a5b8f1d1c2d57c43aca85c615f871180f48502f25b9d38d0be7f2e71ef1ff4d19d140c23b1a1e3510abcc6405b702d7020f038b2a93067d220df2ef07ee624a214143471482e75b1d60aa350a3d21ff174c80cb30cc4a6a39023c042ba9578e360cdb6909a046dc2ed4e3cf233bc325379b388724b25e682d7b09ff";
+    hex"02192ac782060c081806c6c1900010012220200283041069000114680901208401260000000000000000000000000000000000000000001000000000000000000000202c49b09d200441910d1e98a7329c08461fd6ea18118eba9713065d3029ab10ec04ac72c00e7ff5a23dae0c8706fb9c253cc7bc2333acb2941b0b5fc712fec72818d295ed35d9a6c50063d58d34dd44c9261df07b012ba09831d9776c0c6cbb422f6d6b2403ae6396082c4e962787daec2841d78a16172ab51a5b8f1d1c2d57c43aca85c615f871180f48502f25b9d38d0be7f2e71ef1ff4d19d140c23b1a1e3510abcc6405b702d7020f038b2a93067d220df2ef07ee624a214143471482e75b1d60aa350a3d21ff174c80cb30cc4a6a39023c042ba9578e360cdb6909a046dc38d89c342ed4e3cf233bc325379b388724b25e682d7b09ff";
 
 /// @dev The build depth of the parser meta.
 
diff --git a/src/lib/op/LibAllStandardOps.sol b/src/lib/op/LibAllStandardOps.sol
index 371f02f73..28e415f73 100644
--- a/src/lib/op/LibAllStandardOps.sol
+++ b/src/lib/op/LibAllStandardOps.sol
@@ -88,7 +88,7 @@ import {LibOpInv} from "./math/LibOpInv.sol";
 import {LibOpMax} from "./math/LibOpMax.sol";
 import {LibOpMaxPositiveValue} from "./math/LibOpMaxPositiveValue.sol";
 import {LibOpMin} from "./math/LibOpMin.sol";
-import {LibOpMinValue} from "./math/LibOpMinValue.sol";
+import {LibOpMinNegativeValue} from "./math/LibOpMinNegativeValue.sol";
 import {LibOpMod} from "./math/LibOpMod.sol";
 // import {LibOpLog2} from "./math/LibOpLog2.sol";
 import {LibOpPow} from "./math/LibOpPow.sol";
@@ -291,7 +291,7 @@ library LibAllStandardOps {
             ),
             AuthoringMetaV2("min", "Finds the minimum number from all inputs."),
             AuthoringMetaV2(
-                "min-value",
+                "min-negative-value",
                 "The minimum representable float value. This is so small that it is effectively negative infinity. Almost all numbers that you could possibly add to it will be ignored as a rounding error."
             ),
             // AuthoringMetaV2("mod", "Modulos the first number by all other numbers. Errors if any divisor is zero."),
@@ -603,7 +603,7 @@ library LibAllStandardOps {
                     LibOpMax.integrity,
                     LibOpMaxPositiveValue.integrity,
                     LibOpMin.integrity,
-                    LibOpMinValue.integrity,
+                    LibOpMinNegativeValue.integrity,
                     // LibOpMod.integrity,
                     LibOpMul.integrity,
                     LibOpPow.integrity,
@@ -712,7 +712,7 @@ library LibAllStandardOps {
                     LibOpMax.run,
                     LibOpMaxPositiveValue.run,
                     LibOpMin.run,
-                    LibOpMinValue.run,
+                    LibOpMinNegativeValue.run,
                     // LibOpMod.run,
                     LibOpMul.run,
                     LibOpPow.run,
diff --git a/src/lib/op/math/LibOpMinValue.sol b/src/lib/op/math/LibOpMinNegativeValue.sol
similarity index 95%
rename from src/lib/op/math/LibOpMinValue.sol
rename to src/lib/op/math/LibOpMinNegativeValue.sol
index 383053b02..9a7bf144c 100644
--- a/src/lib/op/math/LibOpMinValue.sol
+++ b/src/lib/op/math/LibOpMinNegativeValue.sol
@@ -7,9 +7,9 @@ import {InterpreterState} from "../../state/LibInterpreterState.sol";
 import {Pointer} from "rain.solmem/lib/LibPointer.sol";
 import {Float, LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol";
 
-/// @title LibOpMinValue
+/// @title LibOpMinNegativeValue
 /// Exposes the minimum representable float value as a Rainlang opcode.
-library LibOpMinValue {
+library LibOpMinNegativeValue {
     using LibDecimalFloat for Float;
 
     function integrity(IntegrityCheckState memory, OperandV2) internal pure returns (uint256, uint256) {
diff --git a/test/src/lib/op/math/LibOpMinNegativeValue.t.sol b/test/src/lib/op/math/LibOpMinNegativeValue.t.sol
new file mode 100644
index 000000000..6c2066909
--- /dev/null
+++ b/test/src/lib/op/math/LibOpMinNegativeValue.t.sol
@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: CAL
+pragma solidity =0.8.25;
+
+import {OpTest} from "test/abstract/OpTest.sol";
+import {LibOpMinNegativeValue} from "src/lib/op/math/LibOpMinNegativeValue.sol";
+import {IntegrityCheckState, BadOpInputsLength} from "src/lib/integrity/LibIntegrityCheck.sol";
+import {
+    IInterpreterV4,
+    OperandV2,
+    SourceIndexV2,
+    FullyQualifiedNamespace,
+    StackItem
+} from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol";
+import {InterpreterState, LibInterpreterState} from "src/lib/state/LibInterpreterState.sol";
+import {LibContext} from "rain.interpreter.interface/lib/caller/LibContext.sol";
+import {IInterpreterStoreV2} from "rain.interpreter.interface/interface/IInterpreterStoreV2.sol";
+import {SignedContextV1} from "rain.interpreter.interface/interface/IInterpreterCallerV3.sol";
+import {LibOperand} from "test/lib/operand/LibOperand.sol";
+import {Float, LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol";
+
+/// @title LibOpMinNegativeValueTest
+/// @notice Test the runtime and integrity time logic of LibOpMinNegativeValue.
+contract LibOpMinNegativeValueTest is OpTest {
+    using LibInterpreterState for InterpreterState;
+    using LibDecimalFloat for Float;
+
+    /// Directly test the integrity logic of LibOpMinNegativeValue.
+    function testOpMinNegativeValueIntegrity(
+        IntegrityCheckState memory state,
+        uint8 inputs,
+        uint8 outputs,
+        uint16 operandData
+    ) external pure {
+        inputs = uint8(bound(inputs, 0, 0x0F));
+        outputs = uint8(bound(outputs, 0, 0x0F));
+        (uint256 calcInputs, uint256 calcOutputs) =
+            LibOpMinNegativeValue.integrity(state, LibOperand.build(inputs, outputs, operandData));
+
+        assertEq(calcInputs, 0);
+        assertEq(calcOutputs, 1);
+    }
+
+    /// Directly test the runtime logic of LibOpMinNegativeValue. This tests that
+    /// the opcode correctly pushes the min value onto the stack.
+    function testOpMinNegativeValueRun() external view {
+        InterpreterState memory state = opTestDefaultInterpreterState();
+        StackItem[] memory inputs = new StackItem[](0);
+        OperandV2 operand = LibOperand.build(0, 1, 0);
+        opReferenceCheck(
+            state,
+            operand,
+            LibOpMinNegativeValue.referenceFn,
+            LibOpMinNegativeValue.integrity,
+            LibOpMinNegativeValue.run,
+            inputs
+        );
+    }
+
+    /// Test the eval of LibOpMinNegativeValue parsed from a string.
+    function testOpMinNegativeValueEval() external view {
+        checkHappy("_: min-negative-value();", Float.unwrap(LibDecimalFloat.FLOAT_MIN_NEGATIVE_VALUE), "");
+    }
+
+    /// Test that a min-negative-value with inputs fails integrity check.
+    function testOpMinNegativeValueEvalFail() public {
+        vm.expectRevert(abi.encodeWithSelector(BadOpInputsLength.selector, 1, 0, 1));
+        bytes memory bytecode = iDeployer.parse2("_: min-negative-value(0x00);");
+        (bytecode);
+    }
+
+    function testOpMinNegativeValueZeroOutputs() external {
+        checkBadOutputs(": min-negative-value();", 0, 1, 0);
+    }
+
+    function testOpMinNegativeValueTwoOutputs() external {
+        checkBadOutputs("_ _: min-negative-value();", 0, 1, 2);
+    }
+}
diff --git a/test/src/lib/op/math/LibOpMinValue.t.sol b/test/src/lib/op/math/LibOpMinValue.t.sol
deleted file mode 100644
index d92502ae5..000000000
--- a/test/src/lib/op/math/LibOpMinValue.t.sol
+++ /dev/null
@@ -1,69 +0,0 @@
-// SPDX-License-Identifier: CAL
-pragma solidity =0.8.25;
-
-import {OpTest} from "test/abstract/OpTest.sol";
-import {LibOpMinValue} from "src/lib/op/math/LibOpMinValue.sol";
-import {IntegrityCheckState, BadOpInputsLength} from "src/lib/integrity/LibIntegrityCheck.sol";
-import {
-    IInterpreterV4,
-    OperandV2,
-    SourceIndexV2,
-    FullyQualifiedNamespace,
-    StackItem
-} from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol";
-import {InterpreterState, LibInterpreterState} from "src/lib/state/LibInterpreterState.sol";
-import {LibContext} from "rain.interpreter.interface/lib/caller/LibContext.sol";
-import {IInterpreterStoreV2} from "rain.interpreter.interface/interface/IInterpreterStoreV2.sol";
-import {SignedContextV1} from "rain.interpreter.interface/interface/IInterpreterCallerV3.sol";
-import {LibOperand} from "test/lib/operand/LibOperand.sol";
-import {Float, LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol";
-
-/// @title LibOpMinValueTest
-/// @notice Test the runtime and integrity time logic of LibOpMinValue.
-contract LibOpMinValueTest is OpTest {
-    using LibInterpreterState for InterpreterState;
-    using LibDecimalFloat for Float;
-
-    /// Directly test the integrity logic of LibOpMinValue.
-    function testOpMinValueIntegrity(IntegrityCheckState memory state, uint8 inputs, uint8 outputs, uint16 operandData)
-        external
-        pure
-    {
-        inputs = uint8(bound(inputs, 0, 0x0F));
-        outputs = uint8(bound(outputs, 0, 0x0F));
-        (uint256 calcInputs, uint256 calcOutputs) =
-            LibOpMinValue.integrity(state, LibOperand.build(inputs, outputs, operandData));
-
-        assertEq(calcInputs, 0);
-        assertEq(calcOutputs, 1);
-    }
-
-    /// Directly test the runtime logic of LibOpMinValue. This tests that the
-    /// opcode correctly pushes the max value onto the stack.
-    function testOpMinValueRun() external view {
-        InterpreterState memory state = opTestDefaultInterpreterState();
-        StackItem[] memory inputs = new StackItem[](0);
-        OperandV2 operand = LibOperand.build(0, 1, 0);
-        opReferenceCheck(state, operand, LibOpMinValue.referenceFn, LibOpMinValue.integrity, LibOpMinValue.run, inputs);
-    }
-
-    /// Test the eval of LibOpMinValue parsed from a string.
-    function testOpMinValueEval() external view {
-        checkHappy("_: min-value();", Float.unwrap(LibDecimalFloat.FLOAT_MIN_NEGATIVE_VALUE), "");
-    }
-
-    /// Test that a min-value with inputs fails integrity check.
-    function testOpMinValueEvalFail() public {
-        vm.expectRevert(abi.encodeWithSelector(BadOpInputsLength.selector, 1, 0, 1));
-        bytes memory bytecode = iDeployer.parse2("_: min-value(0x00);");
-        (bytecode);
-    }
-
-    function testOpMinValueZeroOutputs() external {
-        checkBadOutputs(": min-value();", 0, 1, 0);
-    }
-
-    function testOpMinValueTwoOutputs() external {
-        checkBadOutputs("_ _: min-value();", 0, 1, 2);
-    }
-}

From fba13c17297400145545eefe1ab2633de90bff8f Mon Sep 17 00:00:00 2001
From: thedavidmeister <thedavidmeister@gmail.com>
Date: Thu, 31 Jul 2025 17:36:18 +0200
Subject: [PATCH 04/10] min positive value

---
 src/generated/Rainterpreter.pointers.sol      |  4 +-
 ...interpreterExpressionDeployer.pointers.sol |  6 +-
 .../RainterpreterParser.pointers.sol          |  8 +-
 src/lib/op/LibAllStandardOps.sol              | 15 +++-
 src/lib/op/math/LibOpMinPositiveValue.sol     | 37 +++++++++
 .../lib/op/math/LibOpMinPositiveValue.t.sol   | 78 +++++++++++++++++++
 6 files changed, 136 insertions(+), 12 deletions(-)
 create mode 100644 src/lib/op/math/LibOpMinPositiveValue.sol
 create mode 100644 test/src/lib/op/math/LibOpMinPositiveValue.t.sol

diff --git a/src/generated/Rainterpreter.pointers.sol b/src/generated/Rainterpreter.pointers.sol
index dc649db8e..c2b437fe1 100644
--- a/src/generated/Rainterpreter.pointers.sol
+++ b/src/generated/Rainterpreter.pointers.sol
@@ -10,11 +10,11 @@
 pragma solidity =0.8.25;
 
 /// @dev Hash of the known bytecode.
-bytes32 constant BYTECODE_HASH = bytes32(0xdd238e0260bb1f2da6c93cc8c68e5f35a2ac83feac46242e5310ae80bf9f37e2);
+bytes32 constant BYTECODE_HASH = bytes32(0x9b9b20453f24850d1c938472253c1acccbe7021666425ba792e886b822505c1e);
 
 /// @dev The function pointers known to the interpreter for dynamic dispatch.
 /// By setting these as a constant they can be inlined into the interpreter
 /// and loaded at eval time for very low gas (~100) due to the compiler
 /// optimising it to a single `codecopy` to build the in memory bytes array.
 bytes constant OPCODE_FUNCTION_POINTERS =
-    hex"08240856087a0a060acf0ae10af30b0c0b300b640b750b860c280c470d050db50e390f7b10ae0d0511a7125912fb137313841395139513a61411151c159b15b415c8162716401659169216bd16d616ef17161729178b17d91827187518c318d1191f196d199e19ac19ba19c81a161a471a951ac61b141b411b8f1c85";
+    hex"082d085f08830a0f0ad80aea0afc0b150b390b6d0b7e0b8f0c310c500d0e0dbe0e420f8410b70d0e11b012621304137c138d139e139e13af141a152515a415bd15d1163016491662169b16c616df16f8171f1732179417e21830187e18cc18da1928197619a719b519c319d11a1f1a501a9e1acf1b001b4e1b7b1bc91cbf";
diff --git a/src/generated/RainterpreterExpressionDeployer.pointers.sol b/src/generated/RainterpreterExpressionDeployer.pointers.sol
index 3bf151231..bd01d605f 100644
--- a/src/generated/RainterpreterExpressionDeployer.pointers.sol
+++ b/src/generated/RainterpreterExpressionDeployer.pointers.sol
@@ -10,11 +10,11 @@
 pragma solidity =0.8.25;
 
 /// @dev Hash of the known bytecode.
-bytes32 constant BYTECODE_HASH = bytes32(0x8871204333d6734d793a9137148e2948b21603ba2e20e3c6cf13274899693a4a);
+bytes32 constant BYTECODE_HASH = bytes32(0x4ef7c853b89f77ce1a7971776d915b41629ff5e10f484f98cd08cd83a7dd3ef8);
 
 /// @dev The hash of the meta that describes the contract.
-bytes32 constant DESCRIBED_BY_META_HASH = bytes32(0x5de1339cce4dd247ad995d5aaf0c2d18cfefdc73fd51217a6f281e76d60a9162);
+bytes32 constant DESCRIBED_BY_META_HASH = bytes32(0x613f064185488d58a0657d4ae05e051bb3ce748710183cac48ccdbd0dda92dc2);
 
 /// @dev The function pointers for the integrity check fns.
 bytes constant INTEGRITY_FUNCTION_POINTERS =
-    hex"0ea80f260f8a1104110e110e11181121113c11e211e2123e12b612c3110e111812c3110e1118110e110e110e1118110411041104110412cd12f2130c110e110e12cd110e110e12c31118110e110e12c3110413161316131613161316111813161330110411181118111813161104131611041330110e13301118130c";
+    hex"0eb00f2e0f92110c1116111611201129114411ea11ea124612be12cb1116112012cb111611201116111611161120110c110c110c110c12d512fa13141116111612d51116111612cb11201116111612cb110c131e131e131e131e131e1120131e1338110c112011201120131e110c131e110c110c13381116133811201314";
diff --git a/src/generated/RainterpreterParser.pointers.sol b/src/generated/RainterpreterParser.pointers.sol
index 5ef1f56da..6b4f5689e 100644
--- a/src/generated/RainterpreterParser.pointers.sol
+++ b/src/generated/RainterpreterParser.pointers.sol
@@ -10,7 +10,7 @@
 pragma solidity =0.8.25;
 
 /// @dev Hash of the known bytecode.
-bytes32 constant BYTECODE_HASH = bytes32(0x8f567366178330788b7901a60e89ed3de53a4e8c436005de92d56db72e2a79c9);
+bytes32 constant BYTECODE_HASH = bytes32(0xd5cd8849e7e3c4650918b70132781e569b948577b1ee29fd7b02893bcf088646);
 
 /// @dev The parse meta that is used to lookup word definitions.
 /// The structure of the parse meta is:
@@ -29,7 +29,7 @@ bytes32 constant BYTECODE_HASH = bytes32(0x8f567366178330788b7901a60e89ed3de53a4
 /// bit count of the previous bloom filter. If we reach the end of the bloom
 /// filters then we have a miss.
 bytes constant PARSE_META =
-    hex"02192ac782060c081806c6c1900010012220200283041069000114680901208401260000000000000000000000000000000000000000001000000000000000000000202c49b09d200441910d1e98a7329c08461fd6ea18118eba9713065d3029ab10ec04ac72c00e7ff5a23dae0c8706fb9c253cc7bc2333acb2941b0b5fc712fec72818d295ed35d9a6c50063d58d34dd44c9261df07b012ba09831d9776c0c6cbb422f6d6b2403ae6396082c4e962787daec2841d78a16172ab51a5b8f1d1c2d57c43aca85c615f871180f48502f25b9d38d0be7f2e71ef1ff4d19d140c23b1a1e3510abcc6405b702d7020f038b2a93067d220df2ef07ee624a214143471482e75b1d60aa350a3d21ff174c80cb30cc4a6a39023c042ba9578e360cdb6909a046dc38d89c342ed4e3cf233bc325379b388724b25e682d7b09ff";
+    hex"02192ac782060c081806c6c1900010012220200283045069000114680901208401260000000000000000000000000000000000000000001000000000000000000000202c49b09d200441910d1e98a7329c08461fd6ea18118eba9713065d3029ab10ec04ac72c00e7ff5a23eae0c8706fb9c253dc7bc2333acb2941b0b5fc712fec72818d295ed35d9a6c50063d58d34dd44c9261df07b39cb6609012ba09831d9776c0c6cbb422f6d6b2403ae6396082c4e962787daec2841d78a16172ab51a5b8f1d1c2d57c43bca85c615f871180f48502f25b9d38d0be7f2e71ef1ff4d19d140c23c1a1e3510abcc6405b702d7020f038b2a93067d220df2ef07ee624a214143471482e75b1d60aa350a3d21ff174c80cb30cc4a6a3a023c042ba9578e360cdb6909a046dc38d89c342ed4e3cf233bc325379b388724b25e682d7b09ff";
 
 /// @dev The build depth of the parser meta.
 
@@ -39,11 +39,11 @@ uint8 constant PARSE_META_BUILD_DEPTH = 2;
 /// These positional indexes all map to the same indexes looked up in the parse
 /// meta.
 bytes constant OPERAND_HANDLER_FUNCTION_POINTERS =
-    hex"1a8d1a8d1a8d1b621c791c791c791b621b621a8d1a8d1a8d1c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791c791a8d1c791c79";
+    hex"1a951a951a951b6a1c811c811c811b6a1b6a1a951a951a951c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811a951c811c81";
 
 /// @dev Every two bytes is a function pointer for a literal parser.
 /// Literal dispatches are determined by the first byte(s) of the literal
 /// rather than a full word lookup, and are done with simple conditional
 /// jumps as the possibilities are limited compared to the number of words we
 /// have.
-bytes constant LITERAL_PARSER_FUNCTION_POINTERS = hex"15d51807184a18e8";
+bytes constant LITERAL_PARSER_FUNCTION_POINTERS = hex"15dd180f185218f0";
diff --git a/src/lib/op/LibAllStandardOps.sol b/src/lib/op/LibAllStandardOps.sol
index 28e415f73..f35fa1b42 100644
--- a/src/lib/op/LibAllStandardOps.sol
+++ b/src/lib/op/LibAllStandardOps.sol
@@ -89,6 +89,7 @@ import {LibOpMax} from "./math/LibOpMax.sol";
 import {LibOpMaxPositiveValue} from "./math/LibOpMaxPositiveValue.sol";
 import {LibOpMin} from "./math/LibOpMin.sol";
 import {LibOpMinNegativeValue} from "./math/LibOpMinNegativeValue.sol";
+import {LibOpMinPositiveValue} from "./math/LibOpMinPositiveValue.sol";
 import {LibOpMod} from "./math/LibOpMod.sol";
 // import {LibOpLog2} from "./math/LibOpLog2.sol";
 import {LibOpPow} from "./math/LibOpPow.sol";
@@ -110,7 +111,7 @@ import {LibParseLiteralHex} from "../parse/literal/LibParseLiteralHex.sol";
 import {LibParseLiteralSubParseable} from "../parse/literal/LibParseLiteralSubParseable.sol";
 
 /// @dev Number of ops currently provided by `AllStandardOps`.
-uint256 constant ALL_STANDARD_OPS_LENGTH = 62;
+uint256 constant ALL_STANDARD_OPS_LENGTH = 63;
 
 /// @title LibAllStandardOps
 /// @notice Every opcode available from the core repository laid out as a single
@@ -294,6 +295,10 @@ library LibAllStandardOps {
                 "min-negative-value",
                 "The minimum representable float value. This is so small that it is effectively negative infinity. Almost all numbers that you could possibly add to it will be ignored as a rounding error."
             ),
+            AuthoringMetaV2(
+                "min-positive-value",
+                "The minimum positive representable float value. This is the smallest number that can be represented that is still greater than zero."
+            ),
             // AuthoringMetaV2("mod", "Modulos the first number by all other numbers. Errors if any divisor is zero."),
             AuthoringMetaV2("mul", "Multiplies all numbers together."),
             AuthoringMetaV2("power", "Raises the first number to the power of the second number."),
@@ -484,11 +489,13 @@ library LibAllStandardOps {
                     // LibParseOperand.handleOperandDisallowed,
                     // max
                     LibParseOperand.handleOperandDisallowed,
-                    // max-value
+                    // max-positive-value
                     LibParseOperand.handleOperandDisallowed,
                     // min
                     LibParseOperand.handleOperandDisallowed,
-                    // min-value
+                    // min-negative-value
+                    LibParseOperand.handleOperandDisallowed,
+                    // min-positive-value
                     LibParseOperand.handleOperandDisallowed,
                     // // mod
                     // LibParseOperand.handleOperandDisallowed,
@@ -604,6 +611,7 @@ library LibAllStandardOps {
                     LibOpMaxPositiveValue.integrity,
                     LibOpMin.integrity,
                     LibOpMinNegativeValue.integrity,
+                    LibOpMinPositiveValue.integrity,
                     // LibOpMod.integrity,
                     LibOpMul.integrity,
                     LibOpPow.integrity,
@@ -713,6 +721,7 @@ library LibAllStandardOps {
                     LibOpMaxPositiveValue.run,
                     LibOpMin.run,
                     LibOpMinNegativeValue.run,
+                    LibOpMinPositiveValue.run,
                     // LibOpMod.run,
                     LibOpMul.run,
                     LibOpPow.run,
diff --git a/src/lib/op/math/LibOpMinPositiveValue.sol b/src/lib/op/math/LibOpMinPositiveValue.sol
new file mode 100644
index 000000000..6353b0b37
--- /dev/null
+++ b/src/lib/op/math/LibOpMinPositiveValue.sol
@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: CAL
+pragma solidity ^0.8.18;
+
+import {IntegrityCheckState} from "../../integrity/LibIntegrityCheck.sol";
+import {OperandV2, StackItem} from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol";
+import {InterpreterState} from "../../state/LibInterpreterState.sol";
+import {Pointer} from "rain.solmem/lib/LibPointer.sol";
+import {Float, LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol";
+
+/// @title LibOpMinPositiveValue
+/// Exposes the minimum positive representable float value as a Rainlang opcode.
+library LibOpMinPositiveValue {
+    using LibDecimalFloat for Float;
+
+    function integrity(IntegrityCheckState memory, OperandV2) internal pure returns (uint256, uint256) {
+        return (0, 1);
+    }
+
+    function run(InterpreterState memory, OperandV2, Pointer stackTop) internal pure returns (Pointer) {
+        Float value = LibDecimalFloat.FLOAT_MIN_POSITIVE_VALUE;
+        assembly ("memory-safe") {
+            stackTop := sub(stackTop, 0x20)
+            mstore(stackTop, value)
+        }
+        return stackTop;
+    }
+
+    function referenceFn(InterpreterState memory, OperandV2, StackItem[] memory)
+        internal
+        pure
+        returns (StackItem[] memory)
+    {
+        StackItem[] memory outputs = new StackItem[](1);
+        outputs[0] = StackItem.wrap(Float.unwrap(LibDecimalFloat.packLossless(1, type(int32).min)));
+        return outputs;
+    }
+}
diff --git a/test/src/lib/op/math/LibOpMinPositiveValue.t.sol b/test/src/lib/op/math/LibOpMinPositiveValue.t.sol
new file mode 100644
index 000000000..f219071b0
--- /dev/null
+++ b/test/src/lib/op/math/LibOpMinPositiveValue.t.sol
@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: CAL
+pragma solidity =0.8.25;
+
+import {OpTest} from "test/abstract/OpTest.sol";
+import {LibOpMinPositiveValue} from "src/lib/op/math/LibOpMinPositiveValue.sol";
+import {IntegrityCheckState, BadOpInputsLength} from "src/lib/integrity/LibIntegrityCheck.sol";
+import {
+    IInterpreterV4,
+    OperandV2,
+    SourceIndexV2,
+    FullyQualifiedNamespace,
+    StackItem
+} from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol";
+import {InterpreterState, LibInterpreterState} from "src/lib/state/LibInterpreterState.sol";
+import {LibContext} from "rain.interpreter.interface/lib/caller/LibContext.sol";
+import {IInterpreterStoreV2} from "rain.interpreter.interface/interface/IInterpreterStoreV2.sol";
+import {SignedContextV1} from "rain.interpreter.interface/interface/IInterpreterCallerV3.sol";
+import {LibOperand} from "test/lib/operand/LibOperand.sol";
+import {Float, LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol";
+
+/// @title LibOpMinPositiveValueTest
+/// @notice Test the runtime and integrity time logic of LibOpMinPositiveValue.
+contract LibOpMinPositiveValueTest is OpTest {
+    using LibInterpreterState for InterpreterState;
+    using LibDecimalFloat for Float;
+
+    /// Directly test the integrity logic of LibOpMinPositiveValue.
+    function testOpMinPositiveValueIntegrity(
+        IntegrityCheckState memory state,
+        uint8 inputs,
+        uint8 outputs,
+        uint16 operandData
+    ) external pure {
+        inputs = uint8(bound(inputs, 0, 0x0F));
+        outputs = uint8(bound(outputs, 0, 0x0F));
+        (uint256 calcInputs, uint256 calcOutputs) =
+            LibOpMinPositiveValue.integrity(state, LibOperand.build(inputs, outputs, operandData));
+
+        assertEq(calcInputs, 0);
+        assertEq(calcOutputs, 1);
+    }
+
+    /// Directly test the runtime logic of LibOpMinPositiveValue. This tests that
+    /// the opcode correctly pushes the min positive value onto the stack.
+    function testOpMinPositiveValueRun() external view {
+        InterpreterState memory state = opTestDefaultInterpreterState();
+        StackItem[] memory inputs = new StackItem[](0);
+        OperandV2 operand = LibOperand.build(0, 1, 0);
+        opReferenceCheck(
+            state,
+            operand,
+            LibOpMinPositiveValue.referenceFn,
+            LibOpMinPositiveValue.integrity,
+            LibOpMinPositiveValue.run,
+            inputs
+        );
+    }
+
+    /// Test the eval of LibOpMinPositiveValue parsed from a string.
+    function testOpMinPositivepValueEval() external view {
+        checkHappy("_: min-positive-value();", Float.unwrap(LibDecimalFloat.FLOAT_MIN_POSITIVE_VALUE), "");
+    }
+
+    /// Test that a min-positive-value with inputs fails integrity check.
+    function testOpMinPositiveValueEvalFail() public {
+        vm.expectRevert(abi.encodeWithSelector(BadOpInputsLength.selector, 1, 0, 1));
+        bytes memory bytecode = iDeployer.parse2("_: min-positive-value(0x00);");
+        (bytecode);
+    }
+
+    function testOpMinPositiveValueZeroOutputs() external {
+        checkBadOutputs(": min-positive-value();", 0, 1, 0);
+    }
+
+    function testOpMinPositiveValueTwoOutputs() external {
+        checkBadOutputs("_ _: min-positive-value();", 0, 1, 2);
+    }
+}

From 07e4dbb79f40ac3120e518216b64ad5d6530cb81 Mon Sep 17 00:00:00 2001
From: thedavidmeister <thedavidmeister@gmail.com>
Date: Thu, 31 Jul 2025 18:01:13 +0200
Subject: [PATCH 05/10] min max consts

---
 .gas-snapshot                                 | 1170 +++++++++--------
 src/generated/Rainterpreter.pointers.sol      |    4 +-
 ...interpreterExpressionDeployer.pointers.sol |    6 +-
 .../RainterpreterParser.pointers.sol          |    8 +-
 src/lib/op/LibAllStandardOps.sol              |   11 +-
 src/lib/op/math/LibOpMaxNegativeValue.sol     |   37 +
 test/src/lib/op/math/LibOpAdd.t.sol           |   66 +-
 test/src/lib/op/math/LibOpDiv.t.sol           |   16 +-
 test/src/lib/op/math/LibOpMax.t.sol           |   58 +-
 .../lib/op/math/LibOpMaxNegativeValue.t.sol   |   76 ++
 test/src/lib/op/math/LibOpMin.t.sol           |  166 ++-
 test/src/lib/op/math/LibOpMul.t.sol           |   16 +-
 test/src/lib/op/math/LibOpSub.t.sol           |    4 +-
 .../lib/op/math/uint256/LibOpUint256Div.t.sol |    8 +-
 .../lib/op/math/uint256/LibOpUint256Mul.t.sol |    2 +-
 .../lib/op/math/uint256/LibOpUint256Pow.t.sol |    2 +-
 16 files changed, 934 insertions(+), 716 deletions(-)
 create mode 100644 src/lib/op/math/LibOpMaxNegativeValue.sol
 create mode 100644 test/src/lib/op/math/LibOpMaxNegativeValue.t.sol

diff --git a/.gas-snapshot b/.gas-snapshot
index 3cbda50a0..bcc18b8a0 100644
--- a/.gas-snapshot
+++ b/.gas-snapshot
@@ -1,642 +1,654 @@
 BaseRainterpreterExternNPE2IERC165Test:testRainterpreterExternNPE2IERC165(bytes4) (runs: 2060, μ: 320946, ~: 320946)
 BaseRainterpreterSubParserNPE2IERC165Test:testRainterpreterSubParserNPE2IERC165(uint32) (runs: 2060, μ: 678755, ~: 678755)
-LibAllStandardOpsTest:testIntegrityAndOpcodeFunctionPointersLength() (gas: 73154)
-LibAllStandardOpsTest:testIntegrityFunctionPointersLength() (gas: 10629)
-LibAllStandardOpsTest:testOpcodeFunctionPointersLength() (gas: 10614)
-LibEvalFBoundsTest:testEvalNPFBoundsModConstant(bytes32) (runs: 2060, μ: 86499, ~: 86499)
+LibAllStandardOpsTest:testIntegrityAndOpcodeFunctionPointersLength() (gas: 75677)
+LibAllStandardOpsTest:testIntegrityFunctionPointersLength() (gas: 10854)
+LibAllStandardOpsTest:testOpcodeFunctionPointersLength() (gas: 10827)
+LibEvalFBoundsTest:testEvalNPFBoundsModConstant(bytes32) (runs: 2060, μ: 86712, ~: 86712)
 LibExternCodecTest:testLibExternCodecEncodeExternCall(uint256,bytes32) (runs: 2060, μ: 9767, ~: 10284)
 LibExternCodecTest:testLibExternCodecEncodeExternDispatch(uint256,bytes32) (runs: 2060, μ: 8884, ~: 9401)
 LibInterpreterStateStackTraceTest:testStackTraceCall(uint256,uint256,uint256[]) (runs: 2060, μ: 43061, ~: 42630)
-LibOpAbsTest:testOpAbsEval() (gas: 293215)
-LibOpAbsTest:testOpAbsEvalOperandDisallowed() (gas: 17580)
+LibOpAbsTest:testOpAbsEval() (gas: 293257)
+LibOpAbsTest:testOpAbsEvalOperandDisallowed() (gas: 17587)
 LibOpAbsTest:testOpAbsIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 13757, ~: 13664)
 LibOpAbsTest:testOpAbsRun(bytes32,uint16) (runs: 2060, μ: 17409, ~: 17349)
-LibOpAbsTest:testOpAbsTwoInputs() (gas: 40006)
-LibOpAbsTest:testOpAbsTwoOutputs() (gas: 35837)
-LibOpAbsTest:testOpAbsZeroInputs() (gas: 30165)
-LibOpAbsTest:testOpAbsZeroOutputs() (gas: 34829)
-LibOpAddTest:testOpAddEval2InputsHappy() (gas: 160798)
-LibOpAddTest:testOpAddEval2InputsHappyZero() (gas: 57711)
-LibOpAddTest:testOpAddEval2InputsHappyZeroMax() (gas: 103075)
-LibOpAddTest:testOpAddEval2InputsHappyZeroOne() (gas: 199120)
-LibOpAddTest:testOpAddEval2InputsUnhappy() (gas: 103211)
-LibOpAddTest:testOpAddEval3InputsHappy() (gas: 309669)
-LibOpAddTest:testOpAddEval3InputsUnhappy() (gas: 709191)
-LibOpAddTest:testOpAddEvalOneInput() (gas: 36624)
-LibOpAddTest:testOpAddEvalOperandDisallowed() (gas: 91651)
-LibOpAddTest:testOpAddEvalTwoOutput() (gas: 44008)
-LibOpAddTest:testOpAddEvalZeroInputs() (gas: 30244)
-LibOpAddTest:testOpAddEvalZeroOutputs() (gas: 43026)
-LibOpAddTest:testOpAddIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18207, ~: 18372)
+LibOpAbsTest:testOpAbsTwoInputs() (gas: 40012)
+LibOpAbsTest:testOpAbsTwoOutputs() (gas: 35843)
+LibOpAbsTest:testOpAbsZeroInputs() (gas: 30172)
+LibOpAbsTest:testOpAbsZeroOutputs() (gas: 34835)
+LibOpAddTest:testOpAddEval2InputsHappy() (gas: 160816)
+LibOpAddTest:testOpAddEval2InputsHappyZero() (gas: 57717)
+LibOpAddTest:testOpAddEval2InputsHappyZeroMax() (gas: 104545)
+LibOpAddTest:testOpAddEval2InputsHappyZeroOne() (gas: 199144)
+LibOpAddTest:testOpAddEval2InputsUnhappy() (gas: 104998)
+LibOpAddTest:testOpAddEval3InputsHappy() (gas: 309704)
+LibOpAddTest:testOpAddEval3InputsUnhappy() (gas: 725603)
+LibOpAddTest:testOpAddEvalOneInput() (gas: 36630)
+LibOpAddTest:testOpAddEvalOperandDisallowed() (gas: 91693)
+LibOpAddTest:testOpAddEvalTwoOutput() (gas: 44014)
+LibOpAddTest:testOpAddEvalZeroInputs() (gas: 30251)
+LibOpAddTest:testOpAddEvalZeroOutputs() (gas: 43032)
+LibOpAddTest:testOpAddIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18210, ~: 18400)
 LibOpAddTest:testOpAddIntegrityUnhappyOneInput((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13877, ~: 13765)
 LibOpAddTest:testOpAddIntegrityUnhappyZeroInputs((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13874, ~: 13762)
-LibOpAddTest:testOpAddRun(bytes32[]) (runs: 2052, μ: 52053, ~: 52098)
-LibOpAnyTest:testOpAnyEval1FalseInput() (gas: 51921)
-LibOpAnyTest:testOpAnyEval1TrueInput() (gas: 51869)
-LibOpAnyTest:testOpAnyEval2FalseInputs() (gas: 57215)
-LibOpAnyTest:testOpAnyEval2MixedInputs() (gas: 57782)
-LibOpAnyTest:testOpAnyEval2MixedInputs2() (gas: 57869)
-LibOpAnyTest:testOpAnyEval2MixedInputsZeroExponent() (gas: 58887)
-LibOpAnyTest:testOpAnyEval2TrueInputs() (gas: 57803)
-LibOpAnyTest:testOpAnyEvalFail() (gas: 29751)
+LibOpAddTest:testOpAddRun(bytes32[]) (runs: 2052, μ: 52133, ~: 51729)
+LibOpAnyTest:testOpAnyEval1FalseInput() (gas: 51927)
+LibOpAnyTest:testOpAnyEval1TrueInput() (gas: 51875)
+LibOpAnyTest:testOpAnyEval2FalseInputs() (gas: 57221)
+LibOpAnyTest:testOpAnyEval2MixedInputs() (gas: 57788)
+LibOpAnyTest:testOpAnyEval2MixedInputs2() (gas: 57875)
+LibOpAnyTest:testOpAnyEval2MixedInputsZeroExponent() (gas: 58893)
+LibOpAnyTest:testOpAnyEval2TrueInputs() (gas: 57809)
+LibOpAnyTest:testOpAnyEvalFail() (gas: 29758)
 LibOpAnyTest:testOpAnyIntegrityGas0() (gas: 3251)
-LibOpAnyTest:testOpAnyIntegrityHappy(uint8,uint16) (runs: 2060, μ: 8291, ~: 8417)
+LibOpAnyTest:testOpAnyIntegrityHappy(uint8,uint16) (runs: 2060, μ: 8295, ~: 8417)
 LibOpAnyTest:testOpAnyIntegrityUnhappyZeroInputs() (gas: 4059)
-LibOpAnyTest:testOpAnyRun(bytes32[],uint16) (runs: 2052, μ: 21816, ~: 21797)
+LibOpAnyTest:testOpAnyRun(bytes32[],uint16) (runs: 2052, μ: 21817, ~: 21797)
 LibOpAnyTest:testOpAnyRunGas0() (gas: 3345)
-LibOpAnyTest:testOpAnyTwoOutputs() (gas: 35807)
-LibOpAnyTest:testOpAnyZeroOutputs() (gas: 34777)
-LibOpBinaryEqualToTest:testOpBinaryEqualToEval2() (gas: 207916)
-LibOpBinaryEqualToTest:testOpBinaryEqualToEval2InputsBothOne() (gas: 57864)
-LibOpBinaryEqualToTest:testOpBinaryEqualToEval2InputsFirstOneSecondZero() (gas: 58593)
-LibOpBinaryEqualToTest:testOpBinaryEqualToEval2InputsFirstZeroSecondOne() (gas: 58595)
-LibOpBinaryEqualToTest:testOpBinaryEqualToEval2ZeroInputs() (gas: 57909)
-LibOpBinaryEqualToTest:testOpBinaryEqualToEvalFail0Inputs() (gas: 30647)
-LibOpBinaryEqualToTest:testOpBinaryEqualToEvalFail1Input() (gas: 34967)
-LibOpBinaryEqualToTest:testOpBinaryEqualToEvalFail3Inputs() (gas: 43465)
-LibOpBinaryEqualToTest:testOpBinaryEqualToIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19708, ~: 19966)
+LibOpAnyTest:testOpAnyTwoOutputs() (gas: 35813)
+LibOpAnyTest:testOpAnyZeroOutputs() (gas: 34783)
+LibOpBinaryEqualToTest:testOpBinaryEqualToEval2() (gas: 207942)
+LibOpBinaryEqualToTest:testOpBinaryEqualToEval2InputsBothOne() (gas: 57870)
+LibOpBinaryEqualToTest:testOpBinaryEqualToEval2InputsFirstOneSecondZero() (gas: 58599)
+LibOpBinaryEqualToTest:testOpBinaryEqualToEval2InputsFirstZeroSecondOne() (gas: 58601)
+LibOpBinaryEqualToTest:testOpBinaryEqualToEval2ZeroInputs() (gas: 57915)
+LibOpBinaryEqualToTest:testOpBinaryEqualToEvalFail0Inputs() (gas: 30654)
+LibOpBinaryEqualToTest:testOpBinaryEqualToEvalFail1Input() (gas: 34973)
+LibOpBinaryEqualToTest:testOpBinaryEqualToEvalFail3Inputs() (gas: 43471)
+LibOpBinaryEqualToTest:testOpBinaryEqualToIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19706, ~: 19972)
 LibOpBinaryEqualToTest:testOpBinaryEqualToRun(bytes32,bytes32) (runs: 2060, μ: 16674, ~: 16674)
-LibOpBinaryEqualToTest:testOpBinaryEqualToTwoOutputs() (gas: 41625)
-LibOpBinaryEqualToTest:testOpBinaryEqualToZeroOutputs() (gas: 40556)
-LibOpBitwiseAndNPTest:testOpBitwiseAndNPEvalHappy() (gas: 720283)
+LibOpBinaryEqualToTest:testOpBinaryEqualToTwoOutputs() (gas: 41631)
+LibOpBinaryEqualToTest:testOpBinaryEqualToZeroOutputs() (gas: 40562)
+LibOpBitwiseAndNPTest:testOpBitwiseAndNPEvalHappy() (gas: 720379)
 LibOpBitwiseAndNPTest:testOpBitwiseAndNPIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 13757, ~: 13664)
 LibOpBitwiseAndNPTest:testOpBitwiseAndNPRun(bytes32,bytes32) (runs: 2060, μ: 16671, ~: 16671)
-LibOpBitwiseAndNPTest:testOpBitwiseORNPEvalBadOperand() (gas: 18225)
-LibOpBitwiseAndNPTest:testOpBitwiseORNPEvalOneInput() (gas: 35781)
-LibOpBitwiseAndNPTest:testOpBitwiseORNPEvalThreeInputs() (gas: 45550)
-LibOpBitwiseAndNPTest:testOpBitwiseORNPEvalTwoOutputs() (gas: 41354)
-LibOpBitwiseAndNPTest:testOpBitwiseORNPEvalZeroInputs() (gas: 30803)
-LibOpBitwiseAndNPTest:testOpBitwiseORNPEvalZeroOutputs() (gas: 40328)
-LibOpBitwiseOrNPTest:testOpBitwiseORNPEval() (gas: 718989)
-LibOpBitwiseOrNPTest:testOpBitwiseORNPEvalBadOperand() (gas: 18166)
-LibOpBitwiseOrNPTest:testOpBitwiseORNPEvalOneInput() (gas: 35722)
-LibOpBitwiseOrNPTest:testOpBitwiseORNPEvalThreeInputs() (gas: 45448)
-LibOpBitwiseOrNPTest:testOpBitwiseORNPEvalTwoOutputs() (gas: 41272)
-LibOpBitwiseOrNPTest:testOpBitwiseORNPEvalZeroInputs() (gas: 30700)
-LibOpBitwiseOrNPTest:testOpBitwiseORNPEvalZeroOutputs() (gas: 40269)
+LibOpBitwiseAndNPTest:testOpBitwiseORNPEvalBadOperand() (gas: 18232)
+LibOpBitwiseAndNPTest:testOpBitwiseORNPEvalOneInput() (gas: 35787)
+LibOpBitwiseAndNPTest:testOpBitwiseORNPEvalThreeInputs() (gas: 45556)
+LibOpBitwiseAndNPTest:testOpBitwiseORNPEvalTwoOutputs() (gas: 41360)
+LibOpBitwiseAndNPTest:testOpBitwiseORNPEvalZeroInputs() (gas: 30810)
+LibOpBitwiseAndNPTest:testOpBitwiseORNPEvalZeroOutputs() (gas: 40334)
+LibOpBitwiseOrNPTest:testOpBitwiseORNPEval() (gas: 719085)
+LibOpBitwiseOrNPTest:testOpBitwiseORNPEvalBadOperand() (gas: 18173)
+LibOpBitwiseOrNPTest:testOpBitwiseORNPEvalOneInput() (gas: 35728)
+LibOpBitwiseOrNPTest:testOpBitwiseORNPEvalThreeInputs() (gas: 45454)
+LibOpBitwiseOrNPTest:testOpBitwiseORNPEvalTwoOutputs() (gas: 41278)
+LibOpBitwiseOrNPTest:testOpBitwiseORNPEvalZeroInputs() (gas: 30707)
+LibOpBitwiseOrNPTest:testOpBitwiseORNPEvalZeroOutputs() (gas: 40275)
 LibOpBitwiseOrNPTest:testOpBitwiseORNPIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 13756, ~: 13663)
 LibOpBitwiseOrNPTest:testOpBitwiseORNPRun(bytes32,bytes32) (runs: 2060, μ: 16628, ~: 16628)
-LibOpBlockNumberTest:testOpBlockNumberEval(uint256) (runs: 2060, μ: 50998, ~: 50767)
-LibOpBlockNumberTest:testOpBlockNumberEvalOneInput() (gas: 35194)
-LibOpBlockNumberTest:testOpBlockNumberEvalTwoOutputs() (gas: 31495)
-LibOpBlockNumberTest:testOpBlockNumberEvalZeroOutputs() (gas: 30486)
-LibOpBlockNumberTest:testOpBlockNumberIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19661, ~: 19891)
-LibOpBlockNumberTest:testOpBlockNumberRun(uint256,uint16) (runs: 2060, μ: 20848, ~: 21044)
-LibOpCallTest:testCallTraceInnerOnly() (gas: 63024)
-LibOpCallTest:testCallTraceOuterOnly() (gas: 45592)
-LibOpCallTest:testOpCallNPIntegrityIO((uint256,uint256,uint256,bytes32[],uint256,bytes),uint256,uint256,uint8,bytes32) (runs: 2056, μ: 39733, ~: 38527)
-LibOpCallTest:testOpCallNPIntegritySourceIndexOutOfBounds((uint256,uint256,uint256,bytes32[],uint256,bytes),uint256,uint256,uint256,uint256,bytes32) (runs: 2060, μ: 59332, ~: 58640)
-LibOpCallTest:testOpCallNPIntegrityTooManyOutputs((uint256,uint256,uint256,bytes32[],uint256,bytes),uint256,uint256,uint8,bytes32) (runs: 2053, μ: 58482, ~: 59051)
-LibOpCallTest:testOpCallNPRunInputsMismatch() (gas: 72599)
-LibOpCallTest:testOpCallNPRunOutputsMismatch() (gas: 65540)
-LibOpCallTest:testOpCallNPRunSourceDoesNotExist() (gas: 350739)
-LibOpChainIdTest:testOpChainIDEval(uint64) (runs: 2060, μ: 47732, ~: 47732)
-LibOpChainIdTest:testOpChainIDIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19686, ~: 19925)
-LibOpChainIdTest:testOpChainIdEvalFail() (gas: 35042)
+LibOpBlockNumberTest:testOpBlockNumberEval(uint256) (runs: 2060, μ: 50999, ~: 50774)
+LibOpBlockNumberTest:testOpBlockNumberEvalOneInput() (gas: 35200)
+LibOpBlockNumberTest:testOpBlockNumberEvalTwoOutputs() (gas: 31502)
+LibOpBlockNumberTest:testOpBlockNumberEvalZeroOutputs() (gas: 30493)
+LibOpBlockNumberTest:testOpBlockNumberIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19651, ~: 19910)
+LibOpBlockNumberTest:testOpBlockNumberRun(uint256,uint16) (runs: 2060, μ: 20846, ~: 21044)
+LibOpCallTest:testCallTraceInnerOnly() (gas: 63030)
+LibOpCallTest:testCallTraceOuterOnly() (gas: 45598)
+LibOpCallTest:testOpCallNPIntegrityIO((uint256,uint256,uint256,bytes32[],uint256,bytes),uint256,uint256,uint8,bytes32) (runs: 2058, μ: 39916, ~: 38789)
+LibOpCallTest:testOpCallNPIntegritySourceIndexOutOfBounds((uint256,uint256,uint256,bytes32[],uint256,bytes),uint256,uint256,uint256,uint256,bytes32) (runs: 2060, μ: 59270, ~: 58514)
+LibOpCallTest:testOpCallNPIntegrityTooManyOutputs((uint256,uint256,uint256,bytes32[],uint256,bytes),uint256,uint256,uint8,bytes32) (runs: 2053, μ: 59169, ~: 59546)
+LibOpCallTest:testOpCallNPRunInputsMismatch() (gas: 72605)
+LibOpCallTest:testOpCallNPRunOutputsMismatch() (gas: 65546)
+LibOpCallTest:testOpCallNPRunSourceDoesNotExist() (gas: 350805)
+LibOpChainIdTest:testOpChainIDEval(uint64) (runs: 2060, μ: 47065, ~: 47065)
+LibOpChainIdTest:testOpChainIDIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19681, ~: 19925)
+LibOpChainIdTest:testOpChainIdEvalFail() (gas: 34374)
 LibOpChainIdTest:testOpChainIdRun(uint64,uint16) (runs: 2060, μ: 17123, ~: 17123)
-LibOpChainIdTest:testOpChainIdTwoOutputs() (gas: 31846)
-LibOpChainIdTest:testOpChainIdZeroOutputs() (gas: 30795)
-LibOpConditionsTest:testOpConditionsEval1FalseInput1TrueInput() (gas: 70620)
-LibOpConditionsTest:testOpConditionsEval1FalseInputRevert() (gas: 54971)
-LibOpConditionsTest:testOpConditionsEval1TrueInput1FalseInput() (gas: 70506)
-LibOpConditionsTest:testOpConditionsEval1TrueInputZeroOutput() (gas: 58738)
-LibOpConditionsTest:testOpConditionsEval2MixedInputs() (gas: 58761)
-LibOpConditionsTest:testOpConditionsEval2TrueInputs() (gas: 70571)
-LibOpConditionsTest:testOpConditionsEvalErrorCode() (gas: 67690)
-LibOpConditionsTest:testOpConditionsEvalFail0Inputs() (gas: 30387)
-LibOpConditionsTest:testOpConditionsEvalFail1Inputs() (gas: 34676)
-LibOpConditionsTest:testOpConditionsEvalUnhappyOperand() (gas: 18108)
-LibOpConditionsTest:testOpConditionsIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 20244, ~: 20464)
-LibOpConditionsTest:testOpConditionsRun(bytes32[],bytes32) (runs: 2052, μ: 19735, ~: 19850)
+LibOpChainIdTest:testOpChainIdTwoOutputs() (gas: 31179)
+LibOpChainIdTest:testOpChainIdZeroOutputs() (gas: 30128)
+LibOpConditionsTest:testOpConditionsEval1FalseInput1TrueInput() (gas: 70626)
+LibOpConditionsTest:testOpConditionsEval1FalseInputRevert() (gas: 54977)
+LibOpConditionsTest:testOpConditionsEval1TrueInput1FalseInput() (gas: 70512)
+LibOpConditionsTest:testOpConditionsEval1TrueInputZeroOutput() (gas: 58744)
+LibOpConditionsTest:testOpConditionsEval2MixedInputs() (gas: 58767)
+LibOpConditionsTest:testOpConditionsEval2TrueInputs() (gas: 70577)
+LibOpConditionsTest:testOpConditionsEvalErrorCode() (gas: 67697)
+LibOpConditionsTest:testOpConditionsEvalFail0Inputs() (gas: 30394)
+LibOpConditionsTest:testOpConditionsEvalFail1Inputs() (gas: 34682)
+LibOpConditionsTest:testOpConditionsEvalUnhappyOperand() (gas: 18115)
+LibOpConditionsTest:testOpConditionsIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 20242, ~: 20469)
+LibOpConditionsTest:testOpConditionsRun(bytes32[],bytes32) (runs: 2052, μ: 19736, ~: 19850)
 LibOpConditionsTest:testOpConditionsRunNoConditionsMet(bytes32[],string) (runs: 2056, μ: 29107, ~: 29334)
-LibOpConditionsTest:testOpConditionsTwoOutputs() (gas: 39977)
-LibOpConditionsTest:testOpConditionsZeroOutputs() (gas: 38927)
-LibOpConstantTest:testOpConstantEvalNPE2E() (gas: 56107)
-LibOpConstantTest:testOpConstantEvalZeroConstants() (gas: 41541)
-LibOpConstantTest:testOpConstantNPIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 19204, ~: 19095)
-LibOpConstantTest:testOpConstantNPIntegrityOOBConstants((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 40182, ~: 39809)
-LibOpConstantTest:testOpConstantNPMultipleOutputErrorSugared() (gas: 31680)
-LibOpConstantTest:testOpConstantNPMultipleOutputErrorUnsugared() (gas: 41620)
-LibOpConstantTest:testOpConstantNPRun(bytes32[],uint16) (runs: 2060, μ: 52424, ~: 51854)
-LibOpConstantTest:testOpConstantNPZeroOutputErrorSugared() (gas: 30296)
-LibOpConstantTest:testOpConstantNPZeroOutputErrorUnsugared() (gas: 40248)
-LibOpContextNPTest:testOpContextNPEval00(bytes32[][]) (runs: 112, μ: 6372575, ~: 5266326)
-LibOpContextNPTest:testOpContextNPEval01(bytes32[][]) (runs: 112, μ: 6398026, ~: 5266507)
-LibOpContextNPTest:testOpContextNPEval10(bytes32[][]) (runs: 112, μ: 6372719, ~: 5266470)
-LibOpContextNPTest:testOpContextNPEval11(bytes32[][]) (runs: 112, μ: 6360032, ~: 5151992)
-LibOpContextNPTest:testOpContextNPEvalOOBi(bytes32[]) (runs: 112, μ: 74635, ~: 72777)
-LibOpContextNPTest:testOpContextNPEvalOOBj(bytes32) (runs: 2060, μ: 48248, ~: 48248)
+LibOpConditionsTest:testOpConditionsTwoOutputs() (gas: 39983)
+LibOpConditionsTest:testOpConditionsZeroOutputs() (gas: 38933)
+LibOpConstantTest:testOpConstantEvalNPE2E() (gas: 56113)
+LibOpConstantTest:testOpConstantEvalZeroConstants() (gas: 41547)
+LibOpConstantTest:testOpConstantNPIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 19202, ~: 19095)
+LibOpConstantTest:testOpConstantNPIntegrityOOBConstants((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 40181, ~: 39809)
+LibOpConstantTest:testOpConstantNPMultipleOutputErrorSugared() (gas: 31686)
+LibOpConstantTest:testOpConstantNPMultipleOutputErrorUnsugared() (gas: 41626)
+LibOpConstantTest:testOpConstantNPRun(bytes32[],uint16) (runs: 2060, μ: 52421, ~: 51854)
+LibOpConstantTest:testOpConstantNPZeroOutputErrorSugared() (gas: 30302)
+LibOpConstantTest:testOpConstantNPZeroOutputErrorUnsugared() (gas: 40254)
+LibOpContextNPTest:testOpContextNPEval00(bytes32[][]) (runs: 112, μ: 6372582, ~: 5266333)
+LibOpContextNPTest:testOpContextNPEval01(bytes32[][]) (runs: 112, μ: 6398033, ~: 5266514)
+LibOpContextNPTest:testOpContextNPEval10(bytes32[][]) (runs: 112, μ: 6372726, ~: 5266477)
+LibOpContextNPTest:testOpContextNPEval11(bytes32[][]) (runs: 112, μ: 6360039, ~: 5151999)
+LibOpContextNPTest:testOpContextNPEvalOOBi(bytes32[]) (runs: 112, μ: 74642, ~: 72784)
+LibOpContextNPTest:testOpContextNPEvalOOBj(bytes32) (runs: 2060, μ: 48255, ~: 48255)
 LibOpContextNPTest:testOpContextNPIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 14508, ~: 14415)
-LibOpContextNPTest:testOpContextNPOneInput() (gas: 41619)
-LibOpContextNPTest:testOpContextNPRun(bytes32[][],uint256,uint256) (runs: 111, μ: 10008980, ~: 7240865)
-LibOpContextNPTest:testOpContextNPRunOOBi(bytes32[][],uint256,uint256) (runs: 112, μ: 10351311, ~: 7923969)
-LibOpContextNPTest:testOpContextNPRunOOBj(bytes32[][],uint256,uint256) (runs: 111, μ: 10361356, ~: 7780069)
-LibOpContextNPTest:testOpContextNPTwoInputs() (gas: 46483)
-LibOpContextNPTest:testOpContextNPTwoOutputs() (gas: 37287)
-LibOpContextNPTest:testOpContextNPZeroOutputs() (gas: 36235)
-LibOpCtPopNPTest:testOpCtPopNPEval(bytes32) (runs: 2060, μ: 74366, ~: 85279)
+LibOpContextNPTest:testOpContextNPOneInput() (gas: 41625)
+LibOpContextNPTest:testOpContextNPRun(bytes32[][],uint256,uint256) (runs: 112, μ: 10005862, ~: 7383211)
+LibOpContextNPTest:testOpContextNPRunOOBi(bytes32[][],uint256,uint256) (runs: 112, μ: 10351306, ~: 7923969)
+LibOpContextNPTest:testOpContextNPRunOOBj(bytes32[][],uint256,uint256) (runs: 112, μ: 10360033, ~: 7924884)
+LibOpContextNPTest:testOpContextNPTwoInputs() (gas: 46489)
+LibOpContextNPTest:testOpContextNPTwoOutputs() (gas: 37294)
+LibOpContextNPTest:testOpContextNPZeroOutputs() (gas: 36242)
+LibOpCtPopNPTest:testOpCtPopNPEval(bytes32) (runs: 2060, μ: 74400, ~: 85286)
 LibOpCtPopNPTest:testOpCtPopNPIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 13755, ~: 13662)
 LibOpCtPopNPTest:testOpCtPopNPRun(bytes32) (runs: 2060, μ: 16698, ~: 16698)
-LibOpCtPopNPTest:testOpCtPopNPTwoInputs() (gas: 41166)
-LibOpCtPopNPTest:testOpCtPopNPTwoOutputs() (gas: 37038)
-LibOpCtPopNPTest:testOpCtPopNPZeroInputs() (gas: 31302)
-LibOpCtPopNPTest:testOpCtPopNPZeroOutputs() (gas: 35987)
-LibOpDecodeBitsNPTest:testOpDecodeBitsNPEvalHappy() (gas: 836064)
-LibOpDecodeBitsNPTest:testOpDecodeBitsNPEvalTwoInputs() (gas: 46995)
-LibOpDecodeBitsNPTest:testOpDecodeBitsNPEvalTwoOutputs() (gas: 42847)
-LibOpDecodeBitsNPTest:testOpDecodeBitsNPEvalZeroInputs() (gas: 37177)
-LibOpDecodeBitsNPTest:testOpDecodeBitsNPEvalZeroOutputs() (gas: 41794)
-LibOpDecodeBitsNPTest:testOpDecodeBitsNPIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint8,uint8) (runs: 2060, μ: 22145, ~: 22224)
-LibOpDecodeBitsNPTest:testOpDecodeBitsNPIntegrityFail((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8) (runs: 2060, μ: 41519, ~: 41632)
+LibOpCtPopNPTest:testOpCtPopNPTwoInputs() (gas: 41172)
+LibOpCtPopNPTest:testOpCtPopNPTwoOutputs() (gas: 37044)
+LibOpCtPopNPTest:testOpCtPopNPZeroInputs() (gas: 31309)
+LibOpCtPopNPTest:testOpCtPopNPZeroOutputs() (gas: 35993)
+LibOpDecodeBitsNPTest:testOpDecodeBitsNPEvalHappy() (gas: 836172)
+LibOpDecodeBitsNPTest:testOpDecodeBitsNPEvalTwoInputs() (gas: 47001)
+LibOpDecodeBitsNPTest:testOpDecodeBitsNPEvalTwoOutputs() (gas: 42853)
+LibOpDecodeBitsNPTest:testOpDecodeBitsNPEvalZeroInputs() (gas: 37184)
+LibOpDecodeBitsNPTest:testOpDecodeBitsNPEvalZeroOutputs() (gas: 41800)
+LibOpDecodeBitsNPTest:testOpDecodeBitsNPIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint8,uint8) (runs: 2060, μ: 22135, ~: 22287)
+LibOpDecodeBitsNPTest:testOpDecodeBitsNPIntegrityFail((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8) (runs: 2060, μ: 41525, ~: 41547)
 LibOpDecodeBitsNPTest:testOpDecodeBitsNPIntegrityFailZeroLength((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8) (runs: 2060, μ: 35715, ~: 35466)
-LibOpDecodeBitsNPTest:testOpDecodeBitsNPRun(bytes32,uint8,uint8) (runs: 2060, μ: 21011, ~: 20814)
+LibOpDecodeBitsNPTest:testOpDecodeBitsNPRun(bytes32,uint8,uint8) (runs: 2060, μ: 21010, ~: 20814)
 LibOpDivTest:testDebugOpDivRun() (gas: 13482)
-LibOpDivTest:testOpDivEvalOneInput() (gas: 126431)
-LibOpDivTest:testOpDivEvalOperandsDisallowed() (gas: 91627)
-LibOpDivTest:testOpDivEvalThreeInputsHappy() (gas: 337590)
-LibOpDivTest:testOpDivEvalThreeInputsUnhappy() (gas: 212052)
-LibOpDivTest:testOpDivEvalThreeInputsUnhappyOverflow() (gas: 63042)
-LibOpDivTest:testOpDivEvalTwoInputsHappy() (gas: 295969)
-LibOpDivTest:testOpDivEvalTwoInputsUnhappy() (gas: 143727)
-LibOpDivTest:testOpDivEvalTwoInputsUnhappyOverflow() (gas: 56438)
-LibOpDivTest:testOpDivEvalTwoOutputs() (gas: 41248)
-LibOpDivTest:testOpDivEvalZeroInputs() (gas: 30200)
-LibOpDivTest:testOpDivEvalZeroOutputs() (gas: 40244)
-LibOpDivTest:testOpDivIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18260, ~: 18486)
+LibOpDivTest:testOpDivEvalOneInput() (gas: 127185)
+LibOpDivTest:testOpDivEvalOperandsDisallowed() (gas: 91669)
+LibOpDivTest:testOpDivEvalThreeInputsHappy() (gas: 337627)
+LibOpDivTest:testOpDivEvalThreeInputsUnhappy() (gas: 212961)
+LibOpDivTest:testOpDivEvalThreeInputsUnhappyOverflow() (gas: 63914)
+LibOpDivTest:testOpDivEvalTwoInputsHappy() (gas: 296005)
+LibOpDivTest:testOpDivEvalTwoInputsUnhappy() (gas: 144474)
+LibOpDivTest:testOpDivEvalTwoInputsUnhappyOverflow() (gas: 57330)
+LibOpDivTest:testOpDivEvalTwoOutputs() (gas: 41254)
+LibOpDivTest:testOpDivEvalZeroInputs() (gas: 30207)
+LibOpDivTest:testOpDivEvalZeroOutputs() (gas: 40250)
+LibOpDivTest:testOpDivIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18259, ~: 18486)
 LibOpDivTest:testOpDivIntegrityUnhappyOneInput((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13830, ~: 13718)
 LibOpDivTest:testOpDivIntegrityUnhappyZeroInputs((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13853, ~: 13741)
-LibOpDivTest:testOpDivRun(bytes32[]) (runs: 2052, μ: 37772, ~: 33786)
-LibOpERC20AllowanceTest:testOpERC20AllowanceEvalFourInputs() (gas: 55878)
-LibOpERC20AllowanceTest:testOpERC20AllowanceEvalHappy(uint256,uint8) (runs: 2060, μ: 72173, ~: 72082)
-LibOpERC20AllowanceTest:testOpERC20AllowanceEvalOneInput() (gas: 37134)
-LibOpERC20AllowanceTest:testOpERC20AllowanceEvalOperandDisallowed() (gas: 18631)
-LibOpERC20AllowanceTest:testOpERC20AllowanceEvalTwoInputs() (gas: 43664)
-LibOpERC20AllowanceTest:testOpERC20AllowanceEvalTwoOutputs() (gas: 50697)
-LibOpERC20AllowanceTest:testOpERC20AllowanceEvalZeroInputs() (gas: 31140)
-LibOpERC20AllowanceTest:testOpERC20AllowanceEvalZeroOutputs() (gas: 49673)
+LibOpDivTest:testOpDivRun(bytes32[]) (runs: 2052, μ: 37154, ~: 33531)
+LibOpERC20AllowanceTest:testOpERC20AllowanceEvalFourInputs() (gas: 55884)
+LibOpERC20AllowanceTest:testOpERC20AllowanceEvalHappy(uint256,uint8) (runs: 2060, μ: 72179, ~: 72088)
+LibOpERC20AllowanceTest:testOpERC20AllowanceEvalOneInput() (gas: 37140)
+LibOpERC20AllowanceTest:testOpERC20AllowanceEvalOperandDisallowed() (gas: 18637)
+LibOpERC20AllowanceTest:testOpERC20AllowanceEvalTwoInputs() (gas: 43671)
+LibOpERC20AllowanceTest:testOpERC20AllowanceEvalTwoOutputs() (gas: 50703)
+LibOpERC20AllowanceTest:testOpERC20AllowanceEvalZeroInputs() (gas: 31147)
+LibOpERC20AllowanceTest:testOpERC20AllowanceEvalZeroOutputs() (gas: 49679)
 LibOpERC20AllowanceTest:testOpERC20AllowanceIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 13719, ~: 13626)
-LibOpERC20AllowanceTest:testOpERC20AllowanceRun(address,address,address,uint256,uint8) (runs: 2059, μ: 27674, ~: 27579)
-LibOpERC20BalanceOfTest:testOpERC20BalanceOfEvalHappy(uint256,uint8) (runs: 2060, μ: 66093, ~: 66093)
-LibOpERC20BalanceOfTest:testOpERC20BalanceOfEvalOneInput() (gas: 37239)
-LibOpERC20BalanceOfTest:testOpERC20BalanceOfEvalOperandDisallowed() (gas: 18689)
-LibOpERC20BalanceOfTest:testOpERC20BalanceOfEvalOverflow(uint256,uint8) (runs: 2048, μ: 62362, ~: 62362)
-LibOpERC20BalanceOfTest:testOpERC20BalanceOfEvalThreeInputs() (gas: 49565)
-LibOpERC20BalanceOfTest:testOpERC20BalanceOfEvalTwoOutputs() (gas: 44434)
-LibOpERC20BalanceOfTest:testOpERC20BalanceOfEvalZeroInputs() (gas: 31199)
-LibOpERC20BalanceOfTest:testOpERC20BalanceOfEvalZeroOutputs() (gas: 43366)
+LibOpERC20AllowanceTest:testOpERC20AllowanceRun(address,address,address,uint256,uint8) (runs: 2059, μ: 27665, ~: 27579)
+LibOpERC20BalanceOfTest:testOpERC20BalanceOfEvalHappy(uint256,uint8) (runs: 2059, μ: 66100, ~: 66100)
+LibOpERC20BalanceOfTest:testOpERC20BalanceOfEvalOneInput() (gas: 37245)
+LibOpERC20BalanceOfTest:testOpERC20BalanceOfEvalOperandDisallowed() (gas: 18695)
+LibOpERC20BalanceOfTest:testOpERC20BalanceOfEvalOverflow(uint256,uint8) (runs: 2049, μ: 62369, ~: 62369)
+LibOpERC20BalanceOfTest:testOpERC20BalanceOfEvalThreeInputs() (gas: 49572)
+LibOpERC20BalanceOfTest:testOpERC20BalanceOfEvalTwoOutputs() (gas: 44441)
+LibOpERC20BalanceOfTest:testOpERC20BalanceOfEvalZeroInputs() (gas: 31206)
+LibOpERC20BalanceOfTest:testOpERC20BalanceOfEvalZeroOutputs() (gas: 43373)
 LibOpERC20BalanceOfTest:testOpERC20BalanceOfIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 13698, ~: 13605)
-LibOpERC20BalanceOfTest:testOpERC20BalanceOfRun(address,address,uint256,uint16,uint8) (runs: 2058, μ: 28009, ~: 28009)
-LibOpERC20TotalSupplyTest:testOpERC20TotalSupplyEvalHappy(uint256,uint8) (runs: 2060, μ: 59262, ~: 59262)
-LibOpERC20TotalSupplyTest:testOpERC20TotalSupplyEvalOperandDisallowed() (gas: 18852)
-LibOpERC20TotalSupplyTest:testOpERC20TotalSupplyEvalOverflow(uint256,uint8) (runs: 2048, μ: 55498, ~: 55498)
-LibOpERC20TotalSupplyTest:testOpERC20TotalSupplyEvalTwoInputs() (gas: 43886)
-LibOpERC20TotalSupplyTest:testOpERC20TotalSupplyEvalTwoOutputs() (gas: 38248)
-LibOpERC20TotalSupplyTest:testOpERC20TotalSupplyEvalZeroInputs() (gas: 31382)
-LibOpERC20TotalSupplyTest:testOpERC20TotalSupplyEvalZeroOutputs() (gas: 37220)
+LibOpERC20BalanceOfTest:testOpERC20BalanceOfRun(address,address,uint256,uint16,uint8) (runs: 2055, μ: 28009, ~: 28009)
+LibOpERC20TotalSupplyTest:testOpERC20TotalSupplyEvalHappy(uint256,uint8) (runs: 2060, μ: 59268, ~: 59268)
+LibOpERC20TotalSupplyTest:testOpERC20TotalSupplyEvalOperandDisallowed() (gas: 18858)
+LibOpERC20TotalSupplyTest:testOpERC20TotalSupplyEvalOverflow(uint256,uint8) (runs: 2048, μ: 55504, ~: 55504)
+LibOpERC20TotalSupplyTest:testOpERC20TotalSupplyEvalTwoInputs() (gas: 43893)
+LibOpERC20TotalSupplyTest:testOpERC20TotalSupplyEvalTwoOutputs() (gas: 38254)
+LibOpERC20TotalSupplyTest:testOpERC20TotalSupplyEvalZeroInputs() (gas: 31389)
+LibOpERC20TotalSupplyTest:testOpERC20TotalSupplyEvalZeroOutputs() (gas: 37226)
 LibOpERC20TotalSupplyTest:testOpERC20TotalSupplyIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 13742, ~: 13649)
 LibOpERC20TotalSupplyTest:testOpERC20TotalSupplyNPRun(address,uint256,uint16,uint8) (runs: 2057, μ: 27211, ~: 27211)
-LibOpERC5313OwnerTest:testOpERC5313OwnerEvalHappy() (gas: 55284)
-LibOpERC5313OwnerTest:testOpERC5313OwnerEvalOperandDisallowed() (gas: 18369)
-LibOpERC5313OwnerTest:testOpERC5313OwnerEvalTwoInputs() (gas: 43482)
-LibOpERC5313OwnerTest:testOpERC5313OwnerEvalTwoOutputs() (gas: 37686)
-LibOpERC5313OwnerTest:testOpERC5313OwnerEvalZeroInputs() (gas: 30976)
-LibOpERC5313OwnerTest:testOpERC5313OwnerEvalZeroOutputs() (gas: 36657)
+LibOpERC5313OwnerTest:testOpERC5313OwnerEvalHappy() (gas: 55290)
+LibOpERC5313OwnerTest:testOpERC5313OwnerEvalOperandDisallowed() (gas: 18376)
+LibOpERC5313OwnerTest:testOpERC5313OwnerEvalTwoInputs() (gas: 43489)
+LibOpERC5313OwnerTest:testOpERC5313OwnerEvalTwoOutputs() (gas: 37692)
+LibOpERC5313OwnerTest:testOpERC5313OwnerEvalZeroInputs() (gas: 30983)
+LibOpERC5313OwnerTest:testOpERC5313OwnerEvalZeroOutputs() (gas: 36663)
 LibOpERC5313OwnerTest:testOpERC5313OwnerOfIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 13759, ~: 13666)
 LibOpERC5313OwnerTest:testOpERC5313OwnerOfRun(address,address,uint16) (runs: 2059, μ: 23615, ~: 23615)
-LibOpERC721BalanceOfTest:testOpERC721BalanceOfEvalHappy(address,address,uint256) (runs: 2057, μ: 105359, ~: 105505)
-LibOpERC721BalanceOfTest:testOpERC721BalanceOfIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19671, ~: 19911)
-LibOpERC721BalanceOfTest:testOpERC721BalanceOfIntegrityFail0() (gas: 30843)
-LibOpERC721BalanceOfTest:testOpERC721BalanceOfIntegrityFail1() (gas: 35133)
-LibOpERC721BalanceOfTest:testOpERC721BalanceOfIntegrityFail3() (gas: 44567)
-LibOpERC721BalanceOfTest:testOpERC721BalanceOfIntegrityFailOperand() (gas: 21573)
-LibOpERC721BalanceOfTest:testOpERC721BalanceOfOneInput() (gas: 35600)
-LibOpERC721BalanceOfTest:testOpERC721BalanceOfRun(address,address,uint256,uint16) (runs: 2057, μ: 26008, ~: 26008)
-LibOpERC721BalanceOfTest:testOpERC721BalanceOfThreeInputs() (gas: 45087)
-LibOpERC721BalanceOfTest:testOpERC721BalanceOfTwoOutputs() (gas: 41093)
-LibOpERC721BalanceOfTest:testOpERC721BalanceOfZeroInputs() (gas: 31277)
-LibOpERC721BalanceOfTest:testOpERC721BalanceOfZeroOutputs() (gas: 39911)
-LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPEvalFail0() (gas: 30726)
-LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPEvalFail1() (gas: 35014)
-LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPEvalFail3() (gas: 44503)
-LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPEvalFailOperand() (gas: 18222)
-LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPEvalHappy(address,uint256,address) (runs: 2059, μ: 96386, ~: 92364)
-LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPEvalOneInput() (gas: 35472)
-LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPEvalThreeInputs() (gas: 44968)
-LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPEvalZeroInputs() (gas: 31173)
-LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPEvalZeroOutputs() (gas: 39762)
+LibOpERC721BalanceOfTest:testOpERC721BalanceOfEvalHappy(address,address,uint256) (runs: 2056, μ: 105364, ~: 105511)
+LibOpERC721BalanceOfTest:testOpERC721BalanceOfIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19675, ~: 19911)
+LibOpERC721BalanceOfTest:testOpERC721BalanceOfIntegrityFail0() (gas: 30850)
+LibOpERC721BalanceOfTest:testOpERC721BalanceOfIntegrityFail1() (gas: 35139)
+LibOpERC721BalanceOfTest:testOpERC721BalanceOfIntegrityFail3() (gas: 44573)
+LibOpERC721BalanceOfTest:testOpERC721BalanceOfIntegrityFailOperand() (gas: 21579)
+LibOpERC721BalanceOfTest:testOpERC721BalanceOfOneInput() (gas: 35606)
+LibOpERC721BalanceOfTest:testOpERC721BalanceOfRun(address,address,uint256,uint16) (runs: 2056, μ: 26008, ~: 26008)
+LibOpERC721BalanceOfTest:testOpERC721BalanceOfThreeInputs() (gas: 45093)
+LibOpERC721BalanceOfTest:testOpERC721BalanceOfTwoOutputs() (gas: 41100)
+LibOpERC721BalanceOfTest:testOpERC721BalanceOfZeroInputs() (gas: 31284)
+LibOpERC721BalanceOfTest:testOpERC721BalanceOfZeroOutputs() (gas: 39917)
+LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPEvalFail0() (gas: 30733)
+LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPEvalFail1() (gas: 35020)
+LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPEvalFail3() (gas: 44509)
+LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPEvalFailOperand() (gas: 18228)
+LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPEvalHappy(address,uint256,address) (runs: 2059, μ: 96653, ~: 92526)
+LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPEvalOneInput() (gas: 35478)
+LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPEvalThreeInputs() (gas: 44974)
+LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPEvalZeroInputs() (gas: 31180)
+LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPEvalZeroOutputs() (gas: 39768)
 LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8) (runs: 2060, μ: 13772, ~: 13701)
 LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPRun(address,bytes32,address,uint16) (runs: 2059, μ: 24201, ~: 24201)
-LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPTwoOutputs() (gas: 40808)
-LibOpETest:testOpEEval() (gas: 44615)
-LibOpETest:testOpEEvalOneInput() (gas: 34280)
-LibOpETest:testOpEEvalTwoOutputs() (gas: 30647)
-LibOpETest:testOpEEvalZeroOutputs() (gas: 29596)
-LibOpETest:testOpEIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19705, ~: 19968)
+LibOpERC721OwnerOfTest:testOpERC721OwnerOfNPTwoOutputs() (gas: 40814)
+LibOpETest:testOpEEval() (gas: 44622)
+LibOpETest:testOpEEvalOneInput() (gas: 34286)
+LibOpETest:testOpEEvalTwoOutputs() (gas: 30654)
+LibOpETest:testOpEEvalZeroOutputs() (gas: 29603)
+LibOpETest:testOpEIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19705, ~: 19952)
 LibOpETest:testOpERun(uint16) (runs: 2060, μ: 16132, ~: 16132)
-LibOpEncodeBitsNPTest:testOpEncodeBitsNPEvalHappy() (gas: 833176)
-LibOpEncodeBitsNPTest:testOpEncodeBitsNPEvalOneInput() (gas: 42070)
-LibOpEncodeBitsNPTest:testOpEncodeBitsNPEvalThreeInputs() (gas: 51817)
-LibOpEncodeBitsNPTest:testOpEncodeBitsNPEvalTwoOutputs() (gas: 47643)
-LibOpEncodeBitsNPTest:testOpEncodeBitsNPEvalZeroInputs() (gas: 37091)
-LibOpEncodeBitsNPTest:testOpEncodeBitsNPEvalZeroOutputs() (gas: 46639)
-LibOpEncodeBitsNPTest:testOpEncodeBitsNPIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8) (runs: 2060, μ: 18146, ~: 18144)
-LibOpEncodeBitsNPTest:testOpEncodeBitsNPIntegrityFail((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8) (runs: 2060, μ: 41732, ~: 41757)
+LibOpEncodeBitsNPTest:testOpEncodeBitsNPEvalHappy() (gas: 833276)
+LibOpEncodeBitsNPTest:testOpEncodeBitsNPEvalOneInput() (gas: 42076)
+LibOpEncodeBitsNPTest:testOpEncodeBitsNPEvalThreeInputs() (gas: 51823)
+LibOpEncodeBitsNPTest:testOpEncodeBitsNPEvalTwoOutputs() (gas: 47649)
+LibOpEncodeBitsNPTest:testOpEncodeBitsNPEvalZeroInputs() (gas: 37098)
+LibOpEncodeBitsNPTest:testOpEncodeBitsNPEvalZeroOutputs() (gas: 46645)
+LibOpEncodeBitsNPTest:testOpEncodeBitsNPIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8) (runs: 2060, μ: 18155, ~: 18148)
+LibOpEncodeBitsNPTest:testOpEncodeBitsNPIntegrityFail((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8) (runs: 2060, μ: 41728, ~: 41757)
 LibOpEncodeBitsNPTest:testOpEncodeBitsNPIntegrityFailZeroLength((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8) (runs: 2060, μ: 35844, ~: 35595)
-LibOpEncodeBitsNPTest:testOpEncodeBitsNPRun(bytes32,bytes32,uint8,uint8) (runs: 2060, μ: 21399, ~: 21212)
-LibOpEnsureTest:testOpEnsureEvalBadOutputs() (gas: 34447)
-LibOpEnsureTest:testOpEnsureEvalBadOutputs2() (gas: 33972)
-LibOpEnsureTest:testOpEnsureEvalHappy() (gas: 166094)
-LibOpEnsureTest:testOpEnsureEvalOne() (gas: 34660)
-LibOpEnsureTest:testOpEnsureEvalThree() (gas: 45377)
-LibOpEnsureTest:testOpEnsureEvalUnhappy() (gas: 164823)
-LibOpEnsureTest:testOpEnsureEvalUnhappyOperand() (gas: 17072)
-LibOpEnsureTest:testOpEnsureEvalZero() (gas: 29656)
-LibOpEnsureTest:testOpEnsureIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19726, ~: 19960)
+LibOpEncodeBitsNPTest:testOpEncodeBitsNPRun(bytes32,bytes32,uint8,uint8) (runs: 2060, μ: 21404, ~: 21212)
+LibOpEnsureTest:testOpEnsureEvalBadOutputs() (gas: 34453)
+LibOpEnsureTest:testOpEnsureEvalBadOutputs2() (gas: 33978)
+LibOpEnsureTest:testOpEnsureEvalHappy() (gas: 166113)
+LibOpEnsureTest:testOpEnsureEvalOne() (gas: 34666)
+LibOpEnsureTest:testOpEnsureEvalThree() (gas: 45384)
+LibOpEnsureTest:testOpEnsureEvalUnhappy() (gas: 164844)
+LibOpEnsureTest:testOpEnsureEvalUnhappyOperand() (gas: 17079)
+LibOpEnsureTest:testOpEnsureEvalZero() (gas: 29663)
+LibOpEnsureTest:testOpEnsureIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19729, ~: 19960)
 LibOpEnsureTest:testOpEnsureIntegrityUnhappy((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13821, ~: 13709)
-LibOpEnsureTest:testOpEnsureOneOutput() (gas: 39615)
-LibOpEnsureTest:testOpEnsureRun(bytes32,string) (runs: 2053, μ: 18056, ~: 18106)
-LibOpEqualToNPTest:testOpEqualToEval2Inputs() (gas: 339427)
-LibOpEqualToNPTest:testOpEqualToEval2InputsBothOne() (gas: 57676)
-LibOpEqualToNPTest:testOpEqualToEval2InputsFirstOneSecondZero() (gas: 58362)
-LibOpEqualToNPTest:testOpEqualToEval2InputsFirstZeroSecondOne() (gas: 58365)
-LibOpEqualToNPTest:testOpEqualToEval2ZeroInputs() (gas: 57699)
-LibOpEqualToNPTest:testOpEqualToEvalFail0Inputs() (gas: 30080)
-LibOpEqualToNPTest:testOpEqualToEvalFail1Input() (gas: 34391)
-LibOpEqualToNPTest:testOpEqualToEvalFail3Inputs() (gas: 42815)
-LibOpEqualToNPTest:testOpEqualToIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19683, ~: 19915)
-LibOpEqualToNPTest:testOpEqualToRun(bytes32,bytes32) (runs: 2060, μ: 17543, ~: 17466)
-LibOpEqualToNPTest:testOpEqualToTwoOutputs() (gas: 41080)
-LibOpEqualToNPTest:testOpEqualToZeroOutputs() (gas: 39989)
-LibOpEveryTest:testOpEveryEval1FalseInput() (gas: 52714)
-LibOpEveryTest:testOpEveryEval1TrueInput() (gas: 52994)
-LibOpEveryTest:testOpEveryEval2FalseInputs() (gas: 57897)
-LibOpEveryTest:testOpEveryEval2MixedInputs() (gas: 58688)
-LibOpEveryTest:testOpEveryEval2MixedInputs2() (gas: 58627)
-LibOpEveryTest:testOpEveryEval2TrueInputs() (gas: 58970)
-LibOpEveryTest:testOpEveryEvalFail() (gas: 30560)
-LibOpEveryTest:testOpEveryEvalZeroWithExponent() (gas: 59667)
-LibOpEveryTest:testOpEveryIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19801, ~: 20033)
+LibOpEnsureTest:testOpEnsureOneOutput() (gas: 39621)
+LibOpEnsureTest:testOpEnsureRun(bytes32,string) (runs: 2053, μ: 18054, ~: 18106)
+LibOpEqualToNPTest:testOpEqualToEval2Inputs() (gas: 339469)
+LibOpEqualToNPTest:testOpEqualToEval2InputsBothOne() (gas: 57682)
+LibOpEqualToNPTest:testOpEqualToEval2InputsFirstOneSecondZero() (gas: 58368)
+LibOpEqualToNPTest:testOpEqualToEval2InputsFirstZeroSecondOne() (gas: 58371)
+LibOpEqualToNPTest:testOpEqualToEval2ZeroInputs() (gas: 57705)
+LibOpEqualToNPTest:testOpEqualToEvalFail0Inputs() (gas: 30087)
+LibOpEqualToNPTest:testOpEqualToEvalFail1Input() (gas: 34397)
+LibOpEqualToNPTest:testOpEqualToEvalFail3Inputs() (gas: 42821)
+LibOpEqualToNPTest:testOpEqualToIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19683, ~: 19925)
+LibOpEqualToNPTest:testOpEqualToRun(bytes32,bytes32) (runs: 2060, μ: 17544, ~: 17466)
+LibOpEqualToNPTest:testOpEqualToTwoOutputs() (gas: 41086)
+LibOpEqualToNPTest:testOpEqualToZeroOutputs() (gas: 39995)
+LibOpEveryTest:testOpEveryEval1FalseInput() (gas: 52046)
+LibOpEveryTest:testOpEveryEval1TrueInput() (gas: 52326)
+LibOpEveryTest:testOpEveryEval2FalseInputs() (gas: 57229)
+LibOpEveryTest:testOpEveryEval2MixedInputs() (gas: 58020)
+LibOpEveryTest:testOpEveryEval2MixedInputs2() (gas: 57959)
+LibOpEveryTest:testOpEveryEval2TrueInputs() (gas: 58302)
+LibOpEveryTest:testOpEveryEvalFail() (gas: 29893)
+LibOpEveryTest:testOpEveryEvalZeroWithExponent() (gas: 58999)
+LibOpEveryTest:testOpEveryIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19807, ~: 20037)
 LibOpEveryTest:testOpEveryIntegrityUnhappyZeroInputs((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13869, ~: 13757)
-LibOpEveryTest:testOpEveryRun(bytes32[]) (runs: 2052, μ: 20838, ~: 20873)
-LibOpEveryTest:testOpEveryTwoOutputs() (gas: 36681)
-LibOpEveryTest:testOpEveryZeroOutputs() (gas: 35652)
-LibOpExternNPTest:testOpExternNPEvalHappy() (gas: 99790)
-LibOpExternNPTest:testOpExternNPEvalMultipleInputsOutputsHappy() (gas: 115360)
-LibOpExternNPTest:testOpExternNPIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),address,uint16,uint8,uint8) (runs: 2060, μ: 34959, ~: 34950)
-LibOpExternNPTest:testOpExternNPIntegrityNotAnExternContract((uint256,uint256,uint256,bytes32[],uint256,bytes),address,uint16,uint8,uint8) (runs: 2060, μ: 53455, ~: 53408)
-LibOpExternNPTest:testOpExternNPRunHappy(address,bytes32[],uint16,bytes32[],bytes32[]) (runs: 2059, μ: 117901, ~: 117725)
-LibOpFloorTest:testOpFloorEval() (gas: 254759)
-LibOpFloorTest:testOpFloorEvalOperandDisallowed() (gas: 17720)
+LibOpEveryTest:testOpEveryRun(bytes32[]) (runs: 2052, μ: 20835, ~: 20873)
+LibOpEveryTest:testOpEveryTwoOutputs() (gas: 36013)
+LibOpEveryTest:testOpEveryZeroOutputs() (gas: 34984)
+LibOpExternNPTest:testOpExternNPEvalHappy() (gas: 99797)
+LibOpExternNPTest:testOpExternNPEvalMultipleInputsOutputsHappy() (gas: 115367)
+LibOpExternNPTest:testOpExternNPIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),address,uint16,uint8,uint8) (runs: 2059, μ: 34984, ~: 34960)
+LibOpExternNPTest:testOpExternNPIntegrityNotAnExternContract((uint256,uint256,uint256,bytes32[],uint256,bytes),address,uint16,uint8,uint8) (runs: 2059, μ: 53530, ~: 53720)
+LibOpExternNPTest:testOpExternNPRunHappy(address,bytes32[],uint16,bytes32[],bytes32[]) (runs: 2059, μ: 117989, ~: 117926)
+LibOpFloorTest:testOpFloorEval() (gas: 254795)
+LibOpFloorTest:testOpFloorEvalOperandDisallowed() (gas: 17727)
 LibOpFloorTest:testOpFloorIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 13756, ~: 13663)
 LibOpFloorTest:testOpFloorRun(bytes32,uint16) (runs: 2060, μ: 17155, ~: 17138)
-LibOpFloorTest:testOpFloorTwoInputs() (gas: 40190)
-LibOpFloorTest:testOpFloorTwoOutputs() (gas: 35998)
-LibOpFloorTest:testOpFloorZeroInputs() (gas: 30328)
-LibOpFloorTest:testOpFloorZeroOutputs() (gas: 34991)
-LibOpFracTest:testOpFracEval() (gas: 337386)
-LibOpFracTest:testOpFracEvalOperandDisallowed() (gas: 17638)
+LibOpFloorTest:testOpFloorTwoInputs() (gas: 40196)
+LibOpFloorTest:testOpFloorTwoOutputs() (gas: 36004)
+LibOpFloorTest:testOpFloorZeroInputs() (gas: 30335)
+LibOpFloorTest:testOpFloorZeroOutputs() (gas: 34997)
+LibOpFracTest:testOpFracEval() (gas: 337434)
+LibOpFracTest:testOpFracEvalOperandDisallowed() (gas: 17645)
 LibOpFracTest:testOpFracIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 13798, ~: 13705)
-LibOpFracTest:testOpFracRun(bytes32,uint16) (runs: 2060, μ: 17114, ~: 17096)
-LibOpFracTest:testOpFracTwoInputs() (gas: 40077)
-LibOpFracTest:testOpFracTwoOutputs() (gas: 35928)
-LibOpFracTest:testOpFracZeroInputs() (gas: 30213)
-LibOpFracTest:testOpFracZeroOutputs() (gas: 34876)
-LibOpGetTest:testLibOpGetEvalKeyNotSet() (gas: 308928)
-LibOpGetTest:testLibOpGetEvalOperandDisallowed() (gas: 57588)
-LibOpGetTest:testLibOpGetEvalSetThenGet() (gas: 522891)
-LibOpGetTest:testLibOpGetEvalStoreAndSetAndGet() (gas: 255678)
-LibOpGetTest:testLibOpGetEvalStoreThenGet() (gas: 476382)
-LibOpGetTest:testLibOpGetEvalThreeInputs() (gas: 45015)
-LibOpGetTest:testLibOpGetEvalTwoInputs() (gas: 39774)
-LibOpGetTest:testLibOpGetEvalTwoOutputs() (gas: 35366)
-LibOpGetTest:testLibOpGetEvalZeroInputs() (gas: 29789)
-LibOpGetTest:testLibOpGetEvalZeroOutputs() (gas: 34336)
-LibOpGetTest:testLibOpGetIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 20566, ~: 20826)
+LibOpFracTest:testOpFracRun(bytes32,uint16) (runs: 2060, μ: 17113, ~: 17096)
+LibOpFracTest:testOpFracTwoInputs() (gas: 40083)
+LibOpFracTest:testOpFracTwoOutputs() (gas: 35934)
+LibOpFracTest:testOpFracZeroInputs() (gas: 30220)
+LibOpFracTest:testOpFracZeroOutputs() (gas: 34882)
+LibOpGetTest:testLibOpGetEvalKeyNotSet() (gas: 308965)
+LibOpGetTest:testLibOpGetEvalOperandDisallowed() (gas: 57616)
+LibOpGetTest:testLibOpGetEvalSetThenGet() (gas: 522940)
+LibOpGetTest:testLibOpGetEvalStoreAndSetAndGet() (gas: 255698)
+LibOpGetTest:testLibOpGetEvalStoreThenGet() (gas: 476432)
+LibOpGetTest:testLibOpGetEvalThreeInputs() (gas: 45022)
+LibOpGetTest:testLibOpGetEvalTwoInputs() (gas: 39780)
+LibOpGetTest:testLibOpGetEvalTwoOutputs() (gas: 35372)
+LibOpGetTest:testLibOpGetEvalZeroInputs() (gas: 29796)
+LibOpGetTest:testLibOpGetEvalZeroOutputs() (gas: 34342)
+LibOpGetTest:testLibOpGetIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 20570, ~: 20799)
 LibOpGetTest:testLibOpGetRunState(bytes32,bytes32,uint16) (runs: 2060, μ: 19634, ~: 19638)
-LibOpGetTest:testLibOpGetRunStateAndStore(bytes32,bytes32,bytes32,uint16) (runs: 2060, μ: 47596, ~: 47610)
+LibOpGetTest:testLibOpGetRunStateAndStore(bytes32,bytes32,bytes32,uint16) (runs: 2060, μ: 47595, ~: 47610)
 LibOpGetTest:testLibOpGetRunStore(bytes32,bytes32,uint16) (runs: 2060, μ: 49831, ~: 49835)
 LibOpGetTest:testLibOpGetRunStoreDifferentNamespace(bytes32,bytes32,uint16) (runs: 2060, μ: 51423, ~: 51427)
 LibOpGetTest:testLibOpGetRunUnset(bytes32,uint16) (runs: 2060, μ: 24664, ~: 24668)
-LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToEval2InputsBothOne() (gas: 59054)
-LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToEval2InputsFirstOneSecondZero() (gas: 59762)
-LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToEval2InputsFirstZeroSecondOne() (gas: 59762)
-LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToEval2ZeroInputs() (gas: 59097)
-LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToEvalFail0Inputs() (gas: 31397)
-LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToEvalFail1Input() (gas: 35825)
-LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToEvalFail3Inputs() (gas: 44174)
+LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToEval2InputsBothOne() (gas: 59060)
+LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToEval2InputsFirstOneSecondZero() (gas: 59769)
+LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToEval2InputsFirstZeroSecondOne() (gas: 59769)
+LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToEval2ZeroInputs() (gas: 59103)
+LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToEvalFail0Inputs() (gas: 31404)
+LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToEvalFail1Input() (gas: 35831)
+LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToEvalFail3Inputs() (gas: 44180)
 LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8) (runs: 2060, μ: 13751, ~: 13680)
 LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToRun(bytes32,bytes32) (runs: 2060, μ: 17394, ~: 17323)
-LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToTwoOutputs() (gas: 43018)
-LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToZeroOutputs() (gas: 41793)
-LibOpGreaterThanTest:testOpGreaterThanEval1_0Gt1() (gas: 58610)
-LibOpGreaterThanTest:testOpGreaterThanEval1_1Gt1_2() (gas: 61211)
-LibOpGreaterThanTest:testOpGreaterThanEval2InputsBothOne() (gas: 57925)
-LibOpGreaterThanTest:testOpGreaterThanEval2InputsFirstOneSecondZero() (gas: 58656)
-LibOpGreaterThanTest:testOpGreaterThanEval2InputsFirstZeroSecondOne() (gas: 58675)
-LibOpGreaterThanTest:testOpGreaterThanEval2ZeroInputs() (gas: 57946)
-LibOpGreaterThanTest:testOpGreaterThanEvalFail0Inputs() (gas: 30448)
-LibOpGreaterThanTest:testOpGreaterThanEvalFail1Input() (gas: 34769)
-LibOpGreaterThanTest:testOpGreaterThanEvalFail3Inputs() (gas: 43110)
-LibOpGreaterThanTest:testOpGreaterThanEvalNeg1Gt0() (gas: 58708)
-LibOpGreaterThanTest:testOpGreaterThanEvalNeg1_1GtNeg1_2() (gas: 61412)
-LibOpGreaterThanTest:testOpGreaterThanIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19700, ~: 19942)
-LibOpGreaterThanTest:testOpGreaterThanRun(bytes32,bytes32) (runs: 2060, μ: 17418, ~: 17347)
-LibOpGreaterThanTest:testOpGreaterThanTwoOutputs() (gas: 41867)
-LibOpGreaterThanTest:testOpGreaterThanZeroOutputs() (gas: 40819)
-LibOpHashNPTest:testOpHashNPEval0Inputs() (gas: 46326)
-LibOpHashNPTest:testOpHashNPEval1Input() (gas: 54936)
-LibOpHashNPTest:testOpHashNPEval2Inputs() (gas: 63278)
-LibOpHashNPTest:testOpHashNPEval2InputsDifferent() (gas: 63951)
-LibOpHashNPTest:testOpHashNPEval2InputsOtherStack() (gas: 78506)
-LibOpHashNPTest:testOpHashNPIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19718, ~: 19965)
+LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToTwoOutputs() (gas: 43025)
+LibOpGreaterThanOrEqualToTest:testOpGreaterThanOrEqualToZeroOutputs() (gas: 41799)
+LibOpGreaterThanTest:testOpGreaterThanEval1_0Gt1() (gas: 58616)
+LibOpGreaterThanTest:testOpGreaterThanEval1_1Gt1_2() (gas: 61217)
+LibOpGreaterThanTest:testOpGreaterThanEval2InputsBothOne() (gas: 57931)
+LibOpGreaterThanTest:testOpGreaterThanEval2InputsFirstOneSecondZero() (gas: 58662)
+LibOpGreaterThanTest:testOpGreaterThanEval2InputsFirstZeroSecondOne() (gas: 58681)
+LibOpGreaterThanTest:testOpGreaterThanEval2ZeroInputs() (gas: 57952)
+LibOpGreaterThanTest:testOpGreaterThanEvalFail0Inputs() (gas: 30455)
+LibOpGreaterThanTest:testOpGreaterThanEvalFail1Input() (gas: 34775)
+LibOpGreaterThanTest:testOpGreaterThanEvalFail3Inputs() (gas: 43116)
+LibOpGreaterThanTest:testOpGreaterThanEvalNeg1Gt0() (gas: 58714)
+LibOpGreaterThanTest:testOpGreaterThanEvalNeg1_1GtNeg1_2() (gas: 61418)
+LibOpGreaterThanTest:testOpGreaterThanIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19701, ~: 19951)
+LibOpGreaterThanTest:testOpGreaterThanRun(bytes32,bytes32) (runs: 2060, μ: 17419, ~: 17347)
+LibOpGreaterThanTest:testOpGreaterThanTwoOutputs() (gas: 41873)
+LibOpGreaterThanTest:testOpGreaterThanZeroOutputs() (gas: 40825)
+LibOpHashNPTest:testOpHashNPEval0Inputs() (gas: 46333)
+LibOpHashNPTest:testOpHashNPEval1Input() (gas: 54942)
+LibOpHashNPTest:testOpHashNPEval2Inputs() (gas: 63284)
+LibOpHashNPTest:testOpHashNPEval2InputsDifferent() (gas: 63958)
+LibOpHashNPTest:testOpHashNPEval2InputsOtherStack() (gas: 78513)
+LibOpHashNPTest:testOpHashNPIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19711, ~: 19975)
 LibOpHashNPTest:testOpHashNPRun(bytes32[]) (runs: 2052, μ: 19458, ~: 19563)
-LibOpHashNPTest:testOpHashNPTwoOutputs() (gas: 30857)
-LibOpHashNPTest:testOpHashNPZeroOutputs() (gas: 29483)
-LibOpIfTest:testOpIfEval3InputsFirstOneSecondTwoThirdThree() (gas: 63699)
-LibOpIfTest:testOpIfEval3InputsFirstOneSecondZeroThirdThree() (gas: 63451)
-LibOpIfTest:testOpIfEval3InputsFirstTwoSecondThreeThirdFour() (gas: 63655)
-LibOpIfTest:testOpIfEval3InputsFirstTwoSecondZeroThirdFour() (gas: 63451)
-LibOpIfTest:testOpIfEval3InputsFirstZeroSecondOneThirdTwo() (gas: 63698)
-LibOpIfTest:testOpIfEval3InputsFirstZeroSecondOneThirdZero() (gas: 62898)
-LibOpIfTest:testOpIfEval3InputsFirstZeroSecondZeroThirdOne() (gas: 62946)
-LibOpIfTest:testOpIfEval3InputsFirstZeroSecondZeroThirdThree() (gas: 62949)
-LibOpIfTest:testOpIfEvalEmptyStringTruthy() (gas: 163788)
-LibOpIfTest:testOpIfEvalFail0Inputs() (gas: 29616)
-LibOpIfTest:testOpIfEvalFail1Input() (gas: 33971)
-LibOpIfTest:testOpIfEvalFail2Inputs() (gas: 38100)
-LibOpIfTest:testOpIfEvalFail4Inputs() (gas: 46468)
-LibOpIfTest:testOpIfEvalTwoOutputs() (gas: 45971)
-LibOpIfTest:testOpIfEvalZeroExponent() (gas: 65003)
-LibOpIfTest:testOpIfEvalZeroOutputs() (gas: 44902)
-LibOpIfTest:testOpIfIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19678, ~: 19905)
+LibOpHashNPTest:testOpHashNPTwoOutputs() (gas: 30864)
+LibOpHashNPTest:testOpHashNPZeroOutputs() (gas: 29490)
+LibOpIfTest:testOpIfEval3InputsFirstOneSecondTwoThirdThree() (gas: 63706)
+LibOpIfTest:testOpIfEval3InputsFirstOneSecondZeroThirdThree() (gas: 63458)
+LibOpIfTest:testOpIfEval3InputsFirstTwoSecondThreeThirdFour() (gas: 63662)
+LibOpIfTest:testOpIfEval3InputsFirstTwoSecondZeroThirdFour() (gas: 63458)
+LibOpIfTest:testOpIfEval3InputsFirstZeroSecondOneThirdTwo() (gas: 63705)
+LibOpIfTest:testOpIfEval3InputsFirstZeroSecondOneThirdZero() (gas: 62904)
+LibOpIfTest:testOpIfEval3InputsFirstZeroSecondZeroThirdOne() (gas: 62952)
+LibOpIfTest:testOpIfEval3InputsFirstZeroSecondZeroThirdThree() (gas: 62955)
+LibOpIfTest:testOpIfEvalEmptyStringTruthy() (gas: 163809)
+LibOpIfTest:testOpIfEvalFail0Inputs() (gas: 29623)
+LibOpIfTest:testOpIfEvalFail1Input() (gas: 33977)
+LibOpIfTest:testOpIfEvalFail2Inputs() (gas: 38106)
+LibOpIfTest:testOpIfEvalFail4Inputs() (gas: 46474)
+LibOpIfTest:testOpIfEvalTwoOutputs() (gas: 45977)
+LibOpIfTest:testOpIfEvalZeroExponent() (gas: 65010)
+LibOpIfTest:testOpIfEvalZeroOutputs() (gas: 44908)
+LibOpIfTest:testOpIfIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19680, ~: 19872)
 LibOpIfTest:testOpIfRun(bytes32,bytes32,bytes32) (runs: 2060, μ: 17013, ~: 17014)
-LibOpInvTest:testOpExpEvalOperandDisallowed() (gas: 17619)
-LibOpInvTest:testOpInvEval() (gas: 176946)
+LibOpInvTest:testOpExpEvalOperandDisallowed() (gas: 17626)
+LibOpInvTest:testOpInvEval() (gas: 176970)
 LibOpInvTest:testOpInvIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 13756, ~: 13663)
 LibOpInvTest:testOpInvRun(int224,int32,uint16) (runs: 2060, μ: 25068, ~: 25219)
-LibOpInvTest:testOpInvTwoInputs() (gas: 40092)
-LibOpInvTest:testOpInvTwoOutputs() (gas: 35878)
-LibOpInvTest:testOpInvZeroInputs() (gas: 30208)
-LibOpInvTest:testOpInvZeroOutputs() (gas: 34871)
-LibOpIsZeroTest:testOpIsZeroEval0e20Input() (gas: 53374)
-LibOpIsZeroTest:testOpIsZeroEval1NonZeroInput() (gas: 52332)
-LibOpIsZeroTest:testOpIsZeroEval1ZeroInput() (gas: 52069)
-LibOpIsZeroTest:testOpIsZeroEvalFail0Inputs() (gas: 29989)
-LibOpIsZeroTest:testOpIsZeroEvalFail2Inputs() (gas: 38548)
-LibOpIsZeroTest:testOpIsZeroNPIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19794, ~: 20088)
+LibOpInvTest:testOpInvTwoInputs() (gas: 40098)
+LibOpInvTest:testOpInvTwoOutputs() (gas: 35884)
+LibOpInvTest:testOpInvZeroInputs() (gas: 30215)
+LibOpInvTest:testOpInvZeroOutputs() (gas: 34877)
+LibOpIsZeroTest:testOpIsZeroEval0e20Input() (gas: 54054)
+LibOpIsZeroTest:testOpIsZeroEval1NonZeroInput() (gas: 53012)
+LibOpIsZeroTest:testOpIsZeroEval1ZeroInput() (gas: 52749)
+LibOpIsZeroTest:testOpIsZeroEvalFail0Inputs() (gas: 30670)
+LibOpIsZeroTest:testOpIsZeroEvalFail2Inputs() (gas: 39228)
+LibOpIsZeroTest:testOpIsZeroNPIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19785, ~: 20008)
 LibOpIsZeroTest:testOpIsZeroRun(bytes32) (runs: 2060, μ: 16420, ~: 16421)
-LibOpIsZeroTest:testOpIsZeroTwoOutputs() (gas: 36383)
-LibOpIsZeroTest:testOpIsZeroZeroOutputs() (gas: 35089)
-LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToEval2InputsBothOne() (gas: 57236)
-LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToEval2InputsFirstOneSecondZero() (gas: 57946)
-LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToEval2InputsFirstZeroSecondOne() (gas: 57967)
-LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToEval2ZeroInputs() (gas: 57260)
-LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToEvalFail0Inputs() (gas: 31132)
-LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToEvalFail1Input() (gas: 35488)
-LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToEvalFail3Inputs() (gas: 43951)
-LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19685, ~: 19912)
-LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToRun(bytes32,bytes32) (runs: 2060, μ: 17400, ~: 17329)
-LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToTwoOutputs() (gas: 42618)
-LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToZeroOutputs() (gas: 41571)
-LibOpLessThanTest:testOpLessThanEval2InputsFirstZeroSecondOne() (gas: 58432)
-LibOpLessThanTest:testOpLessThanEval2ZeroInputs() (gas: 57681)
-LibOpLessThanTest:testOpLessThanIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19708, ~: 19956)
-LibOpLessThanTest:testOpLessThanNP1_0Lt1() (gas: 58434)
-LibOpLessThanTest:testOpLessThanNP1_1Lt1_2() (gas: 60924)
-LibOpLessThanTest:testOpLessThanNPEval2InputsBothOne() (gas: 57705)
-LibOpLessThanTest:testOpLessThanNPEval2InputsFirstOneSecondZero() (gas: 58389)
-LibOpLessThanTest:testOpLessThanNPMinus1Lt0() (gas: 58487)
-LibOpLessThanTest:testOpLessThanNPMinus1_1LtMinus1_2() (gas: 61148)
-LibOpLessThanTest:testOpLessThanNPTwoOutputs() (gas: 41953)
-LibOpLessThanTest:testOpLessThanNPZeroOutputs() (gas: 40068)
-LibOpLessThanTest:testOpLessThanRun(bytes32,bytes32) (runs: 2060, μ: 17426, ~: 17353)
-LibOpLessThanTest:testOpLessThanToNPEvalFail0Inputs() (gas: 30183)
-LibOpLessThanTest:testOpLessThanToNPEvalFail1Input() (gas: 34473)
-LibOpLessThanTest:testOpLessThanToNPEvalFail3Inputs() (gas: 42853)
-LibOpLinearGrowthTest:testOpLinearGrowthEval() (gas: 783798)
-LibOpLinearGrowthTest:testOpLinearGrowthEvalFourInputs() (gas: 51212)
-LibOpLinearGrowthTest:testOpLinearGrowthEvalOneInput() (gas: 36039)
-LibOpLinearGrowthTest:testOpLinearGrowthEvalOperandDisallowed() (gas: 18407)
-LibOpLinearGrowthTest:testOpLinearGrowthEvalTwoInputs() (gas: 41388)
-LibOpLinearGrowthTest:testOpLinearGrowthEvalTwoOutputs() (gas: 46904)
-LibOpLinearGrowthTest:testOpLinearGrowthEvalZeroInputs() (gas: 30631)
-LibOpLinearGrowthTest:testOpLinearGrowthEvalZeroOutputs() (gas: 45855)
+LibOpIsZeroTest:testOpIsZeroTwoOutputs() (gas: 37063)
+LibOpIsZeroTest:testOpIsZeroZeroOutputs() (gas: 35769)
+LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToEval2InputsBothOne() (gas: 57242)
+LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToEval2InputsFirstOneSecondZero() (gas: 57952)
+LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToEval2InputsFirstZeroSecondOne() (gas: 57973)
+LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToEval2ZeroInputs() (gas: 57266)
+LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToEvalFail0Inputs() (gas: 31139)
+LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToEvalFail1Input() (gas: 35494)
+LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToEvalFail3Inputs() (gas: 43957)
+LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19678, ~: 19931)
+LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToRun(bytes32,bytes32) (runs: 2060, μ: 17402, ~: 17329)
+LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToTwoOutputs() (gas: 42624)
+LibOpLessThanOrEqualToTest:testOpLessThanOrEqualToZeroOutputs() (gas: 41577)
+LibOpLessThanTest:testOpLessThanEval2InputsFirstZeroSecondOne() (gas: 58438)
+LibOpLessThanTest:testOpLessThanEval2ZeroInputs() (gas: 57687)
+LibOpLessThanTest:testOpLessThanIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19710, ~: 19966)
+LibOpLessThanTest:testOpLessThanNP1_0Lt1() (gas: 58440)
+LibOpLessThanTest:testOpLessThanNP1_1Lt1_2() (gas: 60930)
+LibOpLessThanTest:testOpLessThanNPEval2InputsBothOne() (gas: 57711)
+LibOpLessThanTest:testOpLessThanNPEval2InputsFirstOneSecondZero() (gas: 58395)
+LibOpLessThanTest:testOpLessThanNPMinus1Lt0() (gas: 58493)
+LibOpLessThanTest:testOpLessThanNPMinus1_1LtMinus1_2() (gas: 61154)
+LibOpLessThanTest:testOpLessThanNPTwoOutputs() (gas: 41959)
+LibOpLessThanTest:testOpLessThanNPZeroOutputs() (gas: 40074)
+LibOpLessThanTest:testOpLessThanRun(bytes32,bytes32) (runs: 2060, μ: 17424, ~: 17353)
+LibOpLessThanTest:testOpLessThanToNPEvalFail0Inputs() (gas: 30190)
+LibOpLessThanTest:testOpLessThanToNPEvalFail1Input() (gas: 34479)
+LibOpLessThanTest:testOpLessThanToNPEvalFail3Inputs() (gas: 42859)
+LibOpLinearGrowthTest:testOpLinearGrowthEval() (gas: 783891)
+LibOpLinearGrowthTest:testOpLinearGrowthEvalFourInputs() (gas: 51218)
+LibOpLinearGrowthTest:testOpLinearGrowthEvalOneInput() (gas: 36045)
+LibOpLinearGrowthTest:testOpLinearGrowthEvalOperandDisallowed() (gas: 18414)
+LibOpLinearGrowthTest:testOpLinearGrowthEvalTwoInputs() (gas: 41394)
+LibOpLinearGrowthTest:testOpLinearGrowthEvalTwoOutputs() (gas: 46910)
+LibOpLinearGrowthTest:testOpLinearGrowthEvalZeroInputs() (gas: 30638)
+LibOpLinearGrowthTest:testOpLinearGrowthEvalZeroOutputs() (gas: 45861)
 LibOpLinearGrowthTest:testOpLinearGrowthIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 13755, ~: 13662)
-LibOpLinearGrowthTest:testOpLinearGrowthRun(int224,int32,int224,int32,int224,int32,uint16) (runs: 2060, μ: 36141, ~: 36743)
-LibOpMaxTest:testOpMaxEval2InputsHappy() (gas: 880826)
-LibOpMaxTest:testOpMaxEval3InputsHappy() (gas: 2030637)
-LibOpMaxTest:testOpMaxEvalOneInput() (gas: 129168)
-LibOpMaxTest:testOpMaxEvalOperandDisallowed() (gas: 58985)
-LibOpMaxTest:testOpMaxEvalTwoOutputs() (gas: 40763)
-LibOpMaxTest:testOpMaxEvalZeroInputs() (gas: 30202)
-LibOpMaxTest:testOpMaxIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18211, ~: 18380)
+LibOpLinearGrowthTest:testOpLinearGrowthRun(int224,int32,int224,int32,int224,int32,uint16) (runs: 2060, μ: 36146, ~: 36756)
+LibOpMaxNegativeValueTest:testOpMaxNegativeValueEval() (gas: 47399)
+LibOpMaxNegativeValueTest:testOpMaxNegativeValueEvalFail() (gas: 35205)
+LibOpMaxNegativeValueTest:testOpMaxNegativeValueRun() (gas: 16187)
+LibOpMaxNegativeValueTest:testOpMaxNegativeValueTwoOutputs() (gas: 31969)
+LibOpMaxNegativeValueTest:testOpMaxNegativeValueZeroOutputs() (gas: 30961)
+LibOpMaxNegativeValueTest:testOpMaxValueIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19670, ~: 19845)
+LibOpMaxPositiveValueTest:testOpMaxPositiveValueEvalFail() (gas: 35204)
+LibOpMaxPositiveValueTest:testOpMaxPositiveValueRun() (gas: 16196)
+LibOpMaxPositiveValueTest:testOpMaxPositiveValueTwoOutputs() (gas: 32034)
+LibOpMaxPositiveValueTest:testOpMaxPositiveValueZeroOutputs() (gas: 30938)
+LibOpMaxPositiveValueTest:testOpMaxPositivepValueEval() (gas: 47441)
+LibOpMaxPositiveValueTest:testOpMaxValueIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19708, ~: 19928)
+LibOpMaxTest:testOpMaxEval2InputsHappy() (gas: 885590)
+LibOpMaxTest:testOpMaxEval3InputsHappy() (gas: 2038875)
+LibOpMaxTest:testOpMaxEvalOneInput() (gas: 129922)
+LibOpMaxTest:testOpMaxEvalOperandDisallowed() (gas: 59013)
+LibOpMaxTest:testOpMaxEvalTwoOutputs() (gas: 40769)
+LibOpMaxTest:testOpMaxEvalZeroInputs() (gas: 30209)
+LibOpMaxTest:testOpMaxIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18215, ~: 18435)
 LibOpMaxTest:testOpMaxIntegrityUnhappyOneInput((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13831, ~: 13719)
 LibOpMaxTest:testOpMaxIntegrityUnhappyZeroInputs((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13853, ~: 13741)
-LibOpMaxTest:testOpMaxRun(bytes32[]) (runs: 2052, μ: 26599, ~: 26397)
-LibOpMaxUint256Test:testOpMaxUint256Eval() (gas: 47321)
-LibOpMaxUint256Test:testOpMaxUint256EvalFail() (gas: 35141)
-LibOpMaxUint256Test:testOpMaxUint256Integrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19655, ~: 19903)
+LibOpMaxTest:testOpMaxRun(bytes32[]) (runs: 2052, μ: 26584, ~: 26441)
+LibOpMaxUint256Test:testOpMaxUint256Eval() (gas: 47328)
+LibOpMaxUint256Test:testOpMaxUint256EvalFail() (gas: 35147)
+LibOpMaxUint256Test:testOpMaxUint256Integrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19664, ~: 19883)
 LibOpMaxUint256Test:testOpMaxUint256Run() (gas: 15997)
-LibOpMaxUint256Test:testOpMaxUint256TwoOutputs() (gas: 31924)
-LibOpMaxUint256Test:testOpMaxUint256ZeroOutputs() (gas: 30829)
-LibOpMaxValueTest:testOpMaxValueEval() (gas: 46707)
-LibOpMaxValueTest:testOpMaxValueEvalFail() (gas: 34449)
-LibOpMaxValueTest:testOpMaxValueIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19658, ~: 19902)
-LibOpMaxValueTest:testOpMaxValueRun() (gas: 16217)
-LibOpMaxValueTest:testOpMaxValueTwoOutputs() (gas: 31298)
-LibOpMaxValueTest:testOpMaxValueZeroOutputs() (gas: 30203)
-LibOpMinTest:testOpMinEval2InputsHappy() (gas: 973677)
-LibOpMinTest:testOpMinEval3InputsHappy() (gas: 3461267)
-LibOpMinTest:testOpMinEvalOneInput() (gas: 126332)
-LibOpMinTest:testOpMinEvalOperandDisallowed() (gas: 59008)
-LibOpMinTest:testOpMinEvalZeroInputs() (gas: 30182)
-LibOpMinTest:testOpMinIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18290, ~: 18477)
+LibOpMaxUint256Test:testOpMaxUint256TwoOutputs() (gas: 31931)
+LibOpMaxUint256Test:testOpMaxUint256ZeroOutputs() (gas: 30836)
+LibOpMinNegativeValueTest:testOpMinNegativeValueEval() (gas: 47419)
+LibOpMinNegativeValueTest:testOpMinNegativeValueEvalFail() (gas: 35227)
+LibOpMinNegativeValueTest:testOpMinNegativeValueIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19690, ~: 19945)
+LibOpMinNegativeValueTest:testOpMinNegativeValueRun() (gas: 16218)
+LibOpMinNegativeValueTest:testOpMinNegativeValueTwoOutputs() (gas: 31990)
+LibOpMinNegativeValueTest:testOpMinNegativeValueZeroOutputs() (gas: 30960)
+LibOpMinPositiveValueTest:testOpMinPositiveValueEvalFail() (gas: 35184)
+LibOpMinPositiveValueTest:testOpMinPositiveValueIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19663, ~: 19888)
+LibOpMinPositiveValueTest:testOpMinPositiveValueRun() (gas: 16218)
+LibOpMinPositiveValueTest:testOpMinPositiveValueTwoOutputs() (gas: 31989)
+LibOpMinPositiveValueTest:testOpMinPositiveValueZeroOutputs() (gas: 30959)
+LibOpMinPositiveValueTest:testOpMinPositivepValueEval() (gas: 47398)
+LibOpMinTest:testOpMinEval2InputsHappy() (gas: 978454)
+LibOpMinTest:testOpMinEval3InputsHappy() (gas: 3502561)
+LibOpMinTest:testOpMinEvalOneInput() (gas: 127086)
+LibOpMinTest:testOpMinEvalOperandDisallowed() (gas: 59036)
+LibOpMinTest:testOpMinEvalZeroInputs() (gas: 30189)
+LibOpMinTest:testOpMinIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18288, ~: 18504)
 LibOpMinTest:testOpMinIntegrityUnhappyOneInput((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13854, ~: 13742)
 LibOpMinTest:testOpMinIntegrityUnhappyZeroInputs((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13831, ~: 13719)
-LibOpMinTest:testOpMinRun(bytes32[],uint16) (runs: 2052, μ: 26539, ~: 26614)
-LibOpMinValueTest:testOpMinValueEval() (gas: 46684)
-LibOpMinValueTest:testOpMinValueEvalFail() (gas: 34515)
-LibOpMinValueTest:testOpMinValueIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19679, ~: 19937)
-LibOpMinValueTest:testOpMinValueRun() (gas: 16210)
-LibOpMinValueTest:testOpMinValueTwoOutputs() (gas: 31275)
-LibOpMinValueTest:testOpMinValueZeroOutputs() (gas: 30225)
+LibOpMinTest:testOpMinRun(bytes32[],uint16) (runs: 2052, μ: 26530, ~: 26581)
 LibOpMulTest:testOpDecimal18MulNPIntegrityUnhappyOneInput((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13832, ~: 13720)
-LibOpMulTest:testOpMulEvalOneInput() (gas: 126366)
-LibOpMulTest:testOpMulEvalOperandsDisallowed() (gas: 91649)
-LibOpMulTest:testOpMulEvalThreeInputsHappy() (gas: 744291)
-LibOpMulTest:testOpMulEvalThreeInputsUnhappyOverflow() (gas: 60841)
-LibOpMulTest:testOpMulEvalTwoInputsHappy() (gas: 523345)
-LibOpMulTest:testOpMulEvalTwoInputsUnhappyOverflow() (gas: 54393)
-LibOpMulTest:testOpMulEvalZeroInputs() (gas: 30245)
-LibOpMulTest:testOpMulIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18246, ~: 18473)
+LibOpMulTest:testOpMulEvalOneInput() (gas: 127120)
+LibOpMulTest:testOpMulEvalOperandsDisallowed() (gas: 91691)
+LibOpMulTest:testOpMulEvalThreeInputsHappy() (gas: 745259)
+LibOpMulTest:testOpMulEvalThreeInputsUnhappyOverflow() (gas: 61734)
+LibOpMulTest:testOpMulEvalTwoInputsHappy() (gas: 524140)
+LibOpMulTest:testOpMulEvalTwoInputsUnhappyOverflow() (gas: 55128)
+LibOpMulTest:testOpMulEvalZeroInputs() (gas: 30252)
+LibOpMulTest:testOpMulIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18250, ~: 18473)
 LibOpMulTest:testOpMulIntegrityUnhappyZeroInputs((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13875, ~: 13763)
-LibOpMulTest:testOpMulRun(bytes32[]) (runs: 2052, μ: 29013, ~: 26565)
-LibOpMulTest:testOpMulTwoOutputs() (gas: 40784)
-LibOpMulTest:testOpMulZeroOutputs() (gas: 39738)
-LibOpPowTest:testOpPowEval() (gas: 541445)
-LibOpPowTest:testOpPowEvalOneInput() (gas: 35370)
-LibOpPowTest:testOpPowEvalOperandDisallowed() (gas: 17783)
+LibOpMulTest:testOpMulRun(bytes32[]) (runs: 2052, μ: 28971, ~: 26565)
+LibOpMulTest:testOpMulTwoOutputs() (gas: 40790)
+LibOpMulTest:testOpMulZeroOutputs() (gas: 39744)
+LibOpPowTest:testOpPowEval() (gas: 541511)
+LibOpPowTest:testOpPowEvalOneInput() (gas: 35376)
+LibOpPowTest:testOpPowEvalOperandDisallowed() (gas: 17790)
 LibOpPowTest:testOpPowIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 13776, ~: 13683)
-LibOpPowTest:testOpPowNegativeBaseError() (gas: 100954)
-LibOpPowTest:testOpPowRun(int224,int32,int224,int32) (runs: 2060, μ: 64999, ~: 68645)
-LibOpPowTest:testOpPowThreeInputs() (gas: 45096)
-LibOpPowTest:testOpPowTwoOutputs() (gas: 40900)
-LibOpPowTest:testOpPowZeroOutputs() (gas: 39895)
+LibOpPowTest:testOpPowNegativeBaseError() (gas: 100966)
+LibOpPowTest:testOpPowRun(int224,int32,int224,int32) (runs: 2060, μ: 64967, ~: 68645)
+LibOpPowTest:testOpPowThreeInputs() (gas: 45102)
+LibOpPowTest:testOpPowTwoOutputs() (gas: 40906)
+LibOpPowTest:testOpPowZeroOutputs() (gas: 39901)
 LibOpSetTest:testLibOpSet(bytes32,bytes32) (runs: 2060, μ: 17660, ~: 17665)
-LibOpSetTest:testLibOpSetEvalOneInput() (gas: 34224)
-LibOpSetTest:testLibOpSetEvalOneOutput() (gas: 39861)
-LibOpSetTest:testLibOpSetEvalOperandsDisallowed() (gas: 56103)
-LibOpSetTest:testLibOpSetEvalSetTwice() (gas: 78290)
-LibOpSetTest:testLibOpSetEvalThreeInputs() (gas: 44656)
-LibOpSetTest:testLibOpSetEvalTwoInputs() (gas: 258702)
-LibOpSetTest:testLibOpSetEvalTwoOutputs() (gas: 40483)
-LibOpSetTest:testLibOpSetEvalZeroInputs() (gas: 29404)
-LibOpSetTest:testLibOpSetIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 20446, ~: 20686)
-LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPEval() (gas: 879690)
-LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPIntegrityFailBadShiftAmount() (gas: 128234)
-LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPIntegrityFailTwoInputs() (gas: 44479)
-LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPIntegrityFailTwoOutputs() (gas: 40363)
-LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPIntegrityFailZeroInputs() (gas: 34638)
-LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPIntegrityFailZeroOutputs() (gas: 39288)
-LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint8) (runs: 2060, μ: 19775, ~: 19726)
+LibOpSetTest:testLibOpSetEvalOneInput() (gas: 34230)
+LibOpSetTest:testLibOpSetEvalOneOutput() (gas: 39867)
+LibOpSetTest:testLibOpSetEvalOperandsDisallowed() (gas: 56131)
+LibOpSetTest:testLibOpSetEvalSetTwice() (gas: 78296)
+LibOpSetTest:testLibOpSetEvalThreeInputs() (gas: 44663)
+LibOpSetTest:testLibOpSetEvalTwoInputs() (gas: 258732)
+LibOpSetTest:testLibOpSetEvalTwoOutputs() (gas: 40489)
+LibOpSetTest:testLibOpSetEvalZeroInputs() (gas: 29411)
+LibOpSetTest:testLibOpSetIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 20453, ~: 20686)
+LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPEval() (gas: 879810)
+LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPIntegrityFailBadShiftAmount() (gas: 128259)
+LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPIntegrityFailTwoInputs() (gas: 44485)
+LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPIntegrityFailTwoOutputs() (gas: 40369)
+LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPIntegrityFailZeroInputs() (gas: 34645)
+LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPIntegrityFailZeroOutputs() (gas: 39294)
+LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint8) (runs: 2059, μ: 19775, ~: 19760)
 LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPIntegrityNoop((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8) (runs: 2060, μ: 35810, ~: 35560)
-LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPIntegrityZero((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 42007, ~: 42587)
-LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPRun(bytes32,uint8) (runs: 2060, μ: 16833, ~: 16833)
-LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPEval() (gas: 1054773)
-LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPIntegrityFailBadShiftAmount() (gas: 128823)
-LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint8) (runs: 112, μ: 19747, ~: 19089)
+LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPIntegrityZero((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 42003, ~: 42519)
+LibOpShiftBitsLeftNPTest:testOpShiftBitsLeftNPRun(bytes32,uint8) (runs: 2059, μ: 16833, ~: 16833)
+LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPEval() (gas: 1054917)
+LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPIntegrityFailBadShiftAmount() (gas: 128847)
+LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint8) (runs: 112, μ: 19804, ~: 19207)
 LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPIntegrityNoop((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8) (runs: 112, μ: 37172, ~: 37164)
-LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPIntegrityZero((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 112, μ: 40981, ~: 41177)
-LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPRun(bytes32,uint8) (runs: 2059, μ: 16836, ~: 16836)
-LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPTwoInputs() (gas: 44603)
-LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPTwoOutputs() (gas: 40423)
-LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPZeroInputs() (gas: 34697)
-LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPZeroOutputs() (gas: 39372)
-LibOpStackNPTest:testOpStackEval() (gas: 66030)
-LibOpStackNPTest:testOpStackEvalSeveral() (gas: 90562)
-LibOpStackNPTest:testOpStackNPIntegrity(bytes,uint256,bytes32[],bytes32) (runs: 2060, μ: 18891, ~: 18656)
-LibOpStackNPTest:testOpStackNPIntegrityOOBStack(bytes,uint16,bytes32[],uint16,uint256) (runs: 2060, μ: 41403, ~: 41563)
-LibOpStackNPTest:testOpStackNPMultipleOutputErrorSugared() (gas: 40041)
-LibOpStackNPTest:testOpStackNPMultipleOutputErrorUnsugared() (gas: 43027)
+LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPIntegrityZero((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 112, μ: 40978, ~: 41177)
+LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPRun(bytes32,uint8) (runs: 2060, μ: 16836, ~: 16836)
+LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPTwoInputs() (gas: 44609)
+LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPTwoOutputs() (gas: 40429)
+LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPZeroInputs() (gas: 34704)
+LibOpShiftBitsRightNPTest:testOpShiftBitsRightNPZeroOutputs() (gas: 39378)
+LibOpStackNPTest:testOpStackEval() (gas: 66036)
+LibOpStackNPTest:testOpStackEvalSeveral() (gas: 90569)
+LibOpStackNPTest:testOpStackNPIntegrity(bytes,uint256,bytes32[],bytes32) (runs: 2060, μ: 18888, ~: 18657)
+LibOpStackNPTest:testOpStackNPIntegrityOOBStack(bytes,uint16,bytes32[],uint16,uint256) (runs: 2060, μ: 41410, ~: 41563)
+LibOpStackNPTest:testOpStackNPMultipleOutputErrorSugared() (gas: 40047)
+LibOpStackNPTest:testOpStackNPMultipleOutputErrorUnsugared() (gas: 43033)
 LibOpStackNPTest:testOpStackNPRun(bytes32[][],uint256) (runs: 112, μ: 2022596, ~: 1852966)
-LibOpStackNPTest:testOpStackNPZeroOutputErrorSugared() (gas: 38586)
-LibOpStackNPTest:testOpStackNPZeroOutputErrorUnsugared() (gas: 41537)
-LibOpSubTest:testOpSubEvalOneInput() (gas: 128989)
-LibOpSubTest:testOpSubEvalThreeInputs() (gas: 226322)
-LibOpSubTest:testOpSubEvalTwoInputs() (gas: 342580)
-LibOpSubTest:testOpSubEvalZeroInputs() (gas: 30163)
-LibOpSubTest:testOpSubIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18250, ~: 18399)
+LibOpStackNPTest:testOpStackNPZeroOutputErrorSugared() (gas: 38592)
+LibOpStackNPTest:testOpStackNPZeroOutputErrorUnsugared() (gas: 41543)
+LibOpSubTest:testOpSubEvalOneInput() (gas: 129743)
+LibOpSubTest:testOpSubEvalThreeInputs() (gas: 226346)
+LibOpSubTest:testOpSubEvalTwoInputs() (gas: 343351)
+LibOpSubTest:testOpSubEvalZeroInputs() (gas: 30170)
+LibOpSubTest:testOpSubIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18256, ~: 18476)
 LibOpSubTest:testOpSubIntegrityUnhappyOneInput((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13831, ~: 13719)
 LibOpSubTest:testOpSubIntegrityUnhappyZeroInputs((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13832, ~: 13720)
-LibOpSubTest:testOpSubRun(bytes32[]) (runs: 2052, μ: 55773, ~: 55073)
-LibOpTimestampTest:testOpBlockTimestampNPEvalFail() (gas: 65879)
-LibOpTimestampTest:testOpBlockTimestampNPTwoOutputs() (gas: 58796)
-LibOpTimestampTest:testOpBlockTimestampNPZeroOutputs() (gas: 56671)
-LibOpTimestampTest:testOpTimestampEval(uint256) (runs: 2060, μ: 85072, ~: 84745)
-LibOpTimestampTest:testOpTimestampIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19682, ~: 19939)
-LibOpTimestampTest:testOpTimestampRun(uint256) (runs: 2060, μ: 20594, ~: 20364)
-LibOpUint256AddTest:testOpUint256AddEvalOneInput() (gas: 128399)
-LibOpUint256AddTest:testOpUint256AddEvalOperandsDisallowed() (gas: 95537)
-LibOpUint256AddTest:testOpUint256AddEvalThreeInputsHappy() (gas: 209853)
-LibOpUint256AddTest:testOpUint256AddEvalThreeInputsUnhappy() (gas: 114866)
-LibOpUint256AddTest:testOpUint256AddEvalTwoInputsHappy() (gas: 280341)
-LibOpUint256AddTest:testOpUint256AddEvalTwoOutputs() (gas: 41454)
-LibOpUint256AddTest:testOpUint256AddEvalZeroInputs() (gas: 30871)
-LibOpUint256AddTest:testOpUint256AddEvalZeroOutputs() (gas: 40385)
-LibOpUint256AddTest:testOpUint256AddIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18255, ~: 18471)
+LibOpSubTest:testOpSubRun(bytes32[]) (runs: 2052, μ: 55776, ~: 54793)
+LibOpTimestampTest:testOpBlockTimestampNPEvalFail() (gas: 65891)
+LibOpTimestampTest:testOpBlockTimestampNPTwoOutputs() (gas: 58810)
+LibOpTimestampTest:testOpBlockTimestampNPZeroOutputs() (gas: 56685)
+LibOpTimestampTest:testOpTimestampEval(uint256) (runs: 2060, μ: 85083, ~: 84759)
+LibOpTimestampTest:testOpTimestampIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19671, ~: 19901)
+LibOpTimestampTest:testOpTimestampRun(uint256) (runs: 2060, μ: 20590, ~: 20364)
+LibOpUint256AddTest:testOpUint256AddEvalOneInput() (gas: 128423)
+LibOpUint256AddTest:testOpUint256AddEvalOperandsDisallowed() (gas: 95579)
+LibOpUint256AddTest:testOpUint256AddEvalThreeInputsHappy() (gas: 209878)
+LibOpUint256AddTest:testOpUint256AddEvalThreeInputsUnhappy() (gas: 114879)
+LibOpUint256AddTest:testOpUint256AddEvalTwoInputsHappy() (gas: 280377)
+LibOpUint256AddTest:testOpUint256AddEvalTwoOutputs() (gas: 41460)
+LibOpUint256AddTest:testOpUint256AddEvalZeroInputs() (gas: 30878)
+LibOpUint256AddTest:testOpUint256AddEvalZeroOutputs() (gas: 40391)
+LibOpUint256AddTest:testOpUint256AddIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18249, ~: 18445)
 LibOpUint256AddTest:testOpUint256AddIntegrityUnhappyOneInput((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13833, ~: 13721)
 LibOpUint256AddTest:testOpUint256AddIntegrityUnhappyZeroInputs((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13831, ~: 13719)
-LibOpUint256AddTest:testOpUint256AddRun(bytes32[]) (runs: 2052, μ: 19970, ~: 19486)
-LibOpUint256DivTest:testOpUint256DivEval2InputsHappy() (gas: 771428)
-LibOpUint256DivTest:testOpUint256DivEval2InputsUnhappy() (gas: 143659)
-LibOpUint256DivTest:testOpUint256DivEval3InputsHappy() (gas: 1407835)
-LibOpUint256DivTest:testOpUint256DivEval3InputsUnhappy() (gas: 479833)
-LibOpUint256DivTest:testOpUint256DivEvalOneInput() (gas: 133095)
-LibOpUint256DivTest:testOpUint256DivEvalOperandDisallowed() (gas: 61556)
-LibOpUint256DivTest:testOpUint256DivEvalTwoOutputs() (gas: 41455)
-LibOpUint256DivTest:testOpUint256DivEvalZeroInputs() (gas: 30872)
-LibOpUint256DivTest:testOpUint256DivEvalZeroOutputs() (gas: 40363)
-LibOpUint256DivTest:testOpUint256DivIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18273, ~: 18470)
+LibOpUint256AddTest:testOpUint256AddRun(bytes32[]) (runs: 2052, μ: 19965, ~: 19486)
+LibOpUint256DivTest:testOpUint256DivEval2InputsHappy() (gas: 771530)
+LibOpUint256DivTest:testOpUint256DivEval2InputsUnhappy() (gas: 143677)
+LibOpUint256DivTest:testOpUint256DivEval3InputsHappy() (gas: 1408015)
+LibOpUint256DivTest:testOpUint256DivEval3InputsUnhappy() (gas: 482943)
+LibOpUint256DivTest:testOpUint256DivEvalOneInput() (gas: 133999)
+LibOpUint256DivTest:testOpUint256DivEvalOperandDisallowed() (gas: 61584)
+LibOpUint256DivTest:testOpUint256DivEvalTwoOutputs() (gas: 41461)
+LibOpUint256DivTest:testOpUint256DivEvalZeroInputs() (gas: 30879)
+LibOpUint256DivTest:testOpUint256DivEvalZeroOutputs() (gas: 40369)
+LibOpUint256DivTest:testOpUint256DivIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18272, ~: 18467)
 LibOpUint256DivTest:testOpUint256DivIntegrityUnhappyOneInput((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13853, ~: 13741)
 LibOpUint256DivTest:testOpUint256DivIntegrityUnhappyZeroInputs((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13833, ~: 13721)
 LibOpUint256DivTest:testOpUint256DivRun(bytes32[]) (runs: 2052, μ: 24849, ~: 25168)
-LibOpUint256ERC20AllowanceTest:testOpERC20AllowanceEvalFourInputs() (gas: 56680)
-LibOpUint256ERC20AllowanceTest:testOpERC20AllowanceEvalHappy(uint256) (runs: 2060, μ: 70319, ~: 70319)
-LibOpUint256ERC20AllowanceTest:testOpERC20AllowanceEvalOneInput() (gas: 37973)
-LibOpUint256ERC20AllowanceTest:testOpERC20AllowanceEvalOperandDisallowed() (gas: 19279)
-LibOpUint256ERC20AllowanceTest:testOpERC20AllowanceEvalTwoInputs() (gas: 44312)
-LibOpUint256ERC20AllowanceTest:testOpERC20AllowanceEvalTwoOutputs() (gas: 51345)
-LibOpUint256ERC20AllowanceTest:testOpERC20AllowanceEvalZeroInputs() (gas: 31766)
-LibOpUint256ERC20AllowanceTest:testOpERC20AllowanceEvalZeroOutputs() (gas: 50321)
+LibOpUint256ERC20AllowanceTest:testOpERC20AllowanceEvalFourInputs() (gas: 56687)
+LibOpUint256ERC20AllowanceTest:testOpERC20AllowanceEvalHappy(uint256) (runs: 2060, μ: 70325, ~: 70325)
+LibOpUint256ERC20AllowanceTest:testOpERC20AllowanceEvalOneInput() (gas: 37979)
+LibOpUint256ERC20AllowanceTest:testOpERC20AllowanceEvalOperandDisallowed() (gas: 19285)
+LibOpUint256ERC20AllowanceTest:testOpERC20AllowanceEvalTwoInputs() (gas: 44319)
+LibOpUint256ERC20AllowanceTest:testOpERC20AllowanceEvalTwoOutputs() (gas: 51351)
+LibOpUint256ERC20AllowanceTest:testOpERC20AllowanceEvalZeroInputs() (gas: 31773)
+LibOpUint256ERC20AllowanceTest:testOpERC20AllowanceEvalZeroOutputs() (gas: 50327)
 LibOpUint256ERC20AllowanceTest:testOpERC20AllowanceIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 13779, ~: 13686)
 LibOpUint256ERC20AllowanceTest:testOpERC20AllowanceRun(address,address,address,uint256) (runs: 2059, μ: 24718, ~: 24718)
-LibOpUint256ERC20BalanceOfTest:testOpERC20BalanceOfEvalHappy(uint256) (runs: 2060, μ: 63378, ~: 63378)
-LibOpUint256ERC20BalanceOfTest:testOpERC20BalanceOfEvalOneInput() (gas: 38012)
-LibOpUint256ERC20BalanceOfTest:testOpERC20BalanceOfEvalOperandDisallowed() (gas: 19337)
-LibOpUint256ERC20BalanceOfTest:testOpERC20BalanceOfEvalThreeInputs() (gas: 50213)
-LibOpUint256ERC20BalanceOfTest:testOpERC20BalanceOfEvalTwoOutputs() (gas: 45082)
-LibOpUint256ERC20BalanceOfTest:testOpERC20BalanceOfEvalZeroInputs() (gas: 31869)
-LibOpUint256ERC20BalanceOfTest:testOpERC20BalanceOfEvalZeroOutputs() (gas: 44037)
+LibOpUint256ERC20BalanceOfTest:testOpERC20BalanceOfEvalHappy(uint256) (runs: 2060, μ: 63385, ~: 63385)
+LibOpUint256ERC20BalanceOfTest:testOpERC20BalanceOfEvalOneInput() (gas: 38018)
+LibOpUint256ERC20BalanceOfTest:testOpERC20BalanceOfEvalOperandDisallowed() (gas: 19343)
+LibOpUint256ERC20BalanceOfTest:testOpERC20BalanceOfEvalThreeInputs() (gas: 50220)
+LibOpUint256ERC20BalanceOfTest:testOpERC20BalanceOfEvalTwoOutputs() (gas: 45089)
+LibOpUint256ERC20BalanceOfTest:testOpERC20BalanceOfEvalZeroInputs() (gas: 31876)
+LibOpUint256ERC20BalanceOfTest:testOpERC20BalanceOfEvalZeroOutputs() (gas: 44044)
 LibOpUint256ERC20BalanceOfTest:testOpERC20BalanceOfIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 13802, ~: 13709)
 LibOpUint256ERC20BalanceOfTest:testOpERC20BalanceOfRun(address,address,uint256,uint16) (runs: 2059, μ: 24168, ~: 24168)
-LibOpUint256ERC20TotalSupplyTest:testOpERC20TotalSupplyEvalHappy(uint256) (runs: 2060, μ: 56480, ~: 56480)
-LibOpUint256ERC20TotalSupplyTest:testOpERC20TotalSupplyEvalOperandDisallowed() (gas: 19500)
-LibOpUint256ERC20TotalSupplyTest:testOpERC20TotalSupplyEvalTwoInputs() (gas: 44534)
-LibOpUint256ERC20TotalSupplyTest:testOpERC20TotalSupplyEvalTwoOutputs() (gas: 38908)
-LibOpUint256ERC20TotalSupplyTest:testOpERC20TotalSupplyEvalZeroInputs() (gas: 32052)
-LibOpUint256ERC20TotalSupplyTest:testOpERC20TotalSupplyEvalZeroOutputs() (gas: 37835)
+LibOpUint256ERC20TotalSupplyTest:testOpERC20TotalSupplyEvalHappy(uint256) (runs: 2060, μ: 56486, ~: 56486)
+LibOpUint256ERC20TotalSupplyTest:testOpERC20TotalSupplyEvalOperandDisallowed() (gas: 19506)
+LibOpUint256ERC20TotalSupplyTest:testOpERC20TotalSupplyEvalTwoInputs() (gas: 44541)
+LibOpUint256ERC20TotalSupplyTest:testOpERC20TotalSupplyEvalTwoOutputs() (gas: 38914)
+LibOpUint256ERC20TotalSupplyTest:testOpERC20TotalSupplyEvalZeroInputs() (gas: 32059)
+LibOpUint256ERC20TotalSupplyTest:testOpERC20TotalSupplyEvalZeroOutputs() (gas: 37841)
 LibOpUint256ERC20TotalSupplyTest:testOpERC20TotalSupplyIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),bytes32) (runs: 2060, μ: 13802, ~: 13709)
 LibOpUint256ERC20TotalSupplyTest:testOpERC20TotalSupplyRun(address,uint256,uint16) (runs: 2059, μ: 23332, ~: 23332)
-LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfEvalHappy(address,address,uint256) (runs: 2059, μ: 104723, ~: 104895)
-LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19690, ~: 19905)
-LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfIntegrityFail0() (gas: 31491)
-LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfIntegrityFail1() (gas: 35875)
-LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfIntegrityFail3() (gas: 45215)
-LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfIntegrityFailOperand() (gas: 22211)
-LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfOneInput() (gas: 36405)
-LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfRun(address,address,uint256,uint16) (runs: 2059, μ: 24211, ~: 24211)
-LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfThreeInputs() (gas: 45735)
-LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfTwoOutputs() (gas: 41731)
-LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfZeroInputs() (gas: 31925)
-LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfZeroOutputs() (gas: 40706)
-LibOpUint256MulTest:testOpUint256MulEvalOneInput() (gas: 128487)
-LibOpUint256MulTest:testOpUint256MulEvalOperandsDisallowed() (gas: 95517)
-LibOpUint256MulTest:testOpUint256MulEvalThreeInputsHappy() (gas: 1015153)
-LibOpUint256MulTest:testOpUint256MulEvalThreeInputsUnhappy() (gas: 640867)
-LibOpUint256MulTest:testOpUint256MulEvalTwoInputsHappy() (gas: 417124)
-LibOpUint256MulTest:testOpUint256MulEvalTwoInputsUnhappy() (gas: 143792)
-LibOpUint256MulTest:testOpUint256MulEvalTwoOutputs() (gas: 41399)
-LibOpUint256MulTest:testOpUint256MulEvalZeroInputs() (gas: 30925)
-LibOpUint256MulTest:testOpUint256MulEvalZeroOutputs() (gas: 40398)
-LibOpUint256MulTest:testOpUint256MulIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18207, ~: 18402)
+LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfEvalHappy(address,address,uint256) (runs: 2058, μ: 104732, ~: 104901)
+LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfIntegrity((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint8,uint16) (runs: 2060, μ: 19686, ~: 19905)
+LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfIntegrityFail0() (gas: 31498)
+LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfIntegrityFail1() (gas: 35881)
+LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfIntegrityFail3() (gas: 45221)
+LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfIntegrityFailOperand() (gas: 22217)
+LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfOneInput() (gas: 36411)
+LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfRun(address,address,uint256,uint16) (runs: 2058, μ: 24211, ~: 24211)
+LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfThreeInputs() (gas: 45741)
+LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfTwoOutputs() (gas: 41738)
+LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfZeroInputs() (gas: 31932)
+LibOpUint256ERC721BalanceOfTest:testOpERC721BalanceOfZeroOutputs() (gas: 40713)
+LibOpUint256MulTest:testOpUint256MulEvalOneInput() (gas: 128511)
+LibOpUint256MulTest:testOpUint256MulEvalOperandsDisallowed() (gas: 95559)
+LibOpUint256MulTest:testOpUint256MulEvalThreeInputsHappy() (gas: 1015276)
+LibOpUint256MulTest:testOpUint256MulEvalThreeInputsUnhappy() (gas: 642388)
+LibOpUint256MulTest:testOpUint256MulEvalTwoInputsHappy() (gas: 417178)
+LibOpUint256MulTest:testOpUint256MulEvalTwoInputsUnhappy() (gas: 143810)
+LibOpUint256MulTest:testOpUint256MulEvalTwoOutputs() (gas: 41405)
+LibOpUint256MulTest:testOpUint256MulEvalZeroInputs() (gas: 30932)
+LibOpUint256MulTest:testOpUint256MulEvalZeroOutputs() (gas: 40404)
+LibOpUint256MulTest:testOpUint256MulIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18211, ~: 18429)
 LibOpUint256MulTest:testOpUint256MulIntegrityUnhappyOneInput((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13875, ~: 13763)
 LibOpUint256MulTest:testOpUint256MulIntegrityUnhappyZeroInputs((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13832, ~: 13720)
-LibOpUint256MulTest:testOpUint256MulRun(bytes32[]) (runs: 2052, μ: 18854, ~: 18918)
-LibOpUint256PowTest:testOpUint256ExpIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18225, ~: 18456)
-LibOpUint256PowTest:testOpUint256PowEval2InputsHappy() (gas: 872348)
-LibOpUint256PowTest:testOpUint256PowEval2InputsUnhappy() (gas: 145772)
-LibOpUint256PowTest:testOpUint256PowEval3InputsHappy() (gas: 1980325)
-LibOpUint256PowTest:testOpUint256PowEval3InputsUnhappy() (gas: 633721)
-LibOpUint256PowTest:testOpUint256PowEvalOneInput() (gas: 132408)
-LibOpUint256PowTest:testOpUint256PowEvalOperandDisallowed() (gas: 62248)
-LibOpUint256PowTest:testOpUint256PowEvalTwoOutputs() (gas: 41584)
-LibOpUint256PowTest:testOpUint256PowEvalZeroInputs() (gas: 31064)
-LibOpUint256PowTest:testOpUint256PowEvalZeroOutputs() (gas: 40516)
+LibOpUint256MulTest:testOpUint256MulRun(bytes32[]) (runs: 2052, μ: 18820, ~: 19078)
+LibOpUint256PowTest:testOpUint256ExpIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18227, ~: 18417)
+LibOpUint256PowTest:testOpUint256PowEval2InputsHappy() (gas: 872462)
+LibOpUint256PowTest:testOpUint256PowEval2InputsUnhappy() (gas: 145790)
+LibOpUint256PowTest:testOpUint256PowEval3InputsHappy() (gas: 1980577)
+LibOpUint256PowTest:testOpUint256PowEval3InputsUnhappy() (gas: 633799)
+LibOpUint256PowTest:testOpUint256PowEvalOneInput() (gas: 133312)
+LibOpUint256PowTest:testOpUint256PowEvalOperandDisallowed() (gas: 62276)
+LibOpUint256PowTest:testOpUint256PowEvalTwoOutputs() (gas: 41590)
+LibOpUint256PowTest:testOpUint256PowEvalZeroInputs() (gas: 31071)
+LibOpUint256PowTest:testOpUint256PowEvalZeroOutputs() (gas: 40522)
 LibOpUint256PowTest:testOpUint256PowIntegrityUnhappyOneInput((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13855, ~: 13743)
 LibOpUint256PowTest:testOpUint256PowIntegrityUnhappyZeroInputs((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13832, ~: 13720)
-LibOpUint256PowTest:testOpUint256PowRun(bytes32[]) (runs: 2052, μ: 19362, ~: 19304)
-LibOpUint256SubTest:testOpUint256SubEvalOneInput() (gas: 128486)
-LibOpUint256SubTest:testOpUint256SubEvalOperandsDisallowed() (gas: 95539)
-LibOpUint256SubTest:testOpUint256SubEvalThreeInputsHappy() (gas: 209728)
-LibOpUint256SubTest:testOpUint256SubEvalThreeInputsUnhappy() (gas: 115039)
-LibOpUint256SubTest:testOpUint256SubEvalTwoInputsHappy() (gas: 280339)
-LibOpUint256SubTest:testOpUint256SubEvalTwoOutputs() (gas: 41443)
-LibOpUint256SubTest:testOpUint256SubEvalZeroInputs() (gas: 30882)
-LibOpUint256SubTest:testOpUint256SubEvalZeroOutputs() (gas: 40375)
-LibOpUint256SubTest:testOpUint256SubIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18251, ~: 18476)
+LibOpUint256PowTest:testOpUint256PowRun(bytes32[]) (runs: 2052, μ: 19372, ~: 19304)
+LibOpUint256SubTest:testOpUint256SubEvalOneInput() (gas: 131206)
+LibOpUint256SubTest:testOpUint256SubEvalOperandsDisallowed() (gas: 99625)
+LibOpUint256SubTest:testOpUint256SubEvalThreeInputsHappy() (gas: 212449)
+LibOpUint256SubTest:testOpUint256SubEvalThreeInputsUnhappy() (gas: 116400)
+LibOpUint256SubTest:testOpUint256SubEvalTwoInputsHappy() (gas: 284419)
+LibOpUint256SubTest:testOpUint256SubEvalTwoOutputs() (gas: 42123)
+LibOpUint256SubTest:testOpUint256SubEvalZeroInputs() (gas: 31563)
+LibOpUint256SubTest:testOpUint256SubEvalZeroOutputs() (gas: 41055)
+LibOpUint256SubTest:testOpUint256SubIntegrityHappy((uint256,uint256,uint256,bytes32[],uint256,bytes),uint8,uint16) (runs: 2060, μ: 18248, ~: 18443)
 LibOpUint256SubTest:testOpUint256SubIntegrityUnhappyOneInput((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13876, ~: 13764)
 LibOpUint256SubTest:testOpUint256SubIntegrityUnhappyZeroInputs((uint256,uint256,uint256,bytes32[],uint256,bytes)) (runs: 2060, μ: 13832, ~: 13720)
-LibOpUint256SubTest:testOpUint256SubRun(bytes32[]) (runs: 2052, μ: 17634, ~: 17687)
+LibOpUint256SubTest:testOpUint256SubRun(bytes32[]) (runs: 2052, μ: 17633, ~: 17687)
 LibParseCommentsTest:testParseCommentAfterSources() (gas: 69689)
 LibParseCommentsTest:testParseCommentBetweenSources() (gas: 69745)
 LibParseCommentsTest:testParseCommentInIgnoredLHS() (gas: 46231)
@@ -995,29 +1007,29 @@ LibParseUnexpectedRightParenTest:testParseUnexpectedRightParen() (gas: 50722)
 LibParseUnexpectedRightParenTest:testParseUnexpectedRightParenNested() (gas: 56990)
 LibSubParseSubParserExternTest:testLibSubParseSubParserExtern(address,uint8,uint8,uint8,uint16,uint8) (runs: 2060, μ: 13232, ~: 13163)
 LibSubParseSubParserExternTest:testLibSubParseSubParserExternConstantsHeightOverflow(address,uint256,uint8,uint8,uint16,uint8) (runs: 2060, μ: 11434, ~: 11167)
-RainterpreterExpressionDeployerDeployCheckTest:testRainterpreterExpressionDeployerDeployNoEIP1820() (gas: 8562701)
-RainterpreterExpressionDeployerDescribedByMetaV1Test:testRainterpreterExpressionDeployerDescribedByMetaV1Happy() (gas: 8574949)
-RainterpreterExpressionDeployerIERC165Test:testRainterpreterExpressionDeployerIERC165(bytes4) (runs: 2060, μ: 8570142, ~: 8570142)
+RainterpreterExpressionDeployerDeployCheckTest:testRainterpreterExpressionDeployerDeployNoEIP1820() (gas: 8595346)
+RainterpreterExpressionDeployerDescribedByMetaV1Test:testRainterpreterExpressionDeployerDescribedByMetaV1Happy() (gas: 8607770)
+RainterpreterExpressionDeployerIERC165Test:testRainterpreterExpressionDeployerIERC165(bytes4) (runs: 2060, μ: 8602787, ~: 8602787)
 RainterpreterExpressionDeployerMetaTest:testRainterpreterExpressionDeployerExpectedConstructionMetaHash() (gas: 6221)
-RainterpreterIERC165Test:testRainterpreterIERC165(bytes4) (runs: 2060, μ: 3368466, ~: 3368466)
-RainterpreterParserIERC165Test:testRainterpreterParserIERC165(bytes4) (runs: 2060, μ: 3522138, ~: 3522138)
-RainterpreterParserParserPragma:testParsePragmaNoPragma() (gas: 17593065)
-RainterpreterParserParserPragma:testParsePragmaSinglePragma() (gas: 10607571)
-RainterpreterParserParserPragma:testParsePragmaWithInterstitial() (gas: 10610863)
-RainterpreterParserPointersTest:testLiteralParserFunctionPointers() (gas: 3521144)
-RainterpreterParserPointersTest:testOperandHandlerFunctionPointers() (gas: 3528598)
-RainterpreterParserPointersTest:testParserParseMeta() (gas: 4545860)
-RainterpreterPointersTest:testOpcodeFunctionPointers() (gas: 3374909)
-RainterpreterReferenceExternContextRainlenTest:testRainterpreterReferenceExterNPE2ContextRainlenHappy() (gas: 2160763)
-RainterpreterReferenceExternContextSenderTest:testRainterpreterReferenceExterNPE2ContextContractHappy() (gas: 2160349)
-RainterpreterReferenceExternContextSenderTest:testRainterpreterReferenceExterNPE2ContextSenderHappy() (gas: 2159046)
+RainterpreterIERC165Test:testRainterpreterIERC165(bytes4) (runs: 2060, μ: 3391514, ~: 3391514)
+RainterpreterParserIERC165Test:testRainterpreterParserIERC165(bytes4) (runs: 2060, μ: 3527746, ~: 3527746)
+RainterpreterParserParserPragma:testParsePragmaNoPragma() (gas: 17621116)
+RainterpreterParserParserPragma:testParsePragmaSinglePragma() (gas: 10624405)
+RainterpreterParserParserPragma:testParsePragmaWithInterstitial() (gas: 10627697)
+RainterpreterParserPointersTest:testLiteralParserFunctionPointers() (gas: 3526752)
+RainterpreterParserPointersTest:testOperandHandlerFunctionPointers() (gas: 3534430)
+RainterpreterParserPointersTest:testParserParseMeta() (gas: 4690394)
+RainterpreterPointersTest:testOpcodeFunctionPointers() (gas: 3398169)
+RainterpreterReferenceExternContextRainlenTest:testRainterpreterReferenceExterNPE2ContextRainlenHappy() (gas: 2160770)
+RainterpreterReferenceExternContextSenderTest:testRainterpreterReferenceExterNPE2ContextContractHappy() (gas: 2160356)
+RainterpreterReferenceExternContextSenderTest:testRainterpreterReferenceExterNPE2ContextSenderHappy() (gas: 2159052)
 RainterpreterReferenceExternDescribedByMetaV1:testRainterpreterReferenceExternDescribedByMetaV1Happy() (gas: 2081641)
 RainterpreterReferenceExternIERC165Test:testRainterpreterReferenceExternIERC165(bytes4) (runs: 2060, μ: 2093899, ~: 2093899)
-RainterpreterReferenceExternIntIncTest:testRainterpreterReferenceExternIntIncHappySugared() (gas: 2184505)
-RainterpreterReferenceExternIntIncTest:testRainterpreterReferenceExternIntIncHappyUnsugared() (gas: 2178069)
+RainterpreterReferenceExternIntIncTest:testRainterpreterReferenceExternIntIncHappySugared() (gas: 2184511)
+RainterpreterReferenceExternIntIncTest:testRainterpreterReferenceExternIntIncHappyUnsugared() (gas: 2178076)
 RainterpreterReferenceExternIntIncTest:testRainterpreterReferenceExternIntIncIntegrity(bytes32,uint256,uint256) (runs: 112, μ: 3597, ~: 3597)
-RainterpreterReferenceExternIntIncTest:testRainterpreterReferenceExternIntIncRun(bytes32,bytes32[]) (runs: 112, μ: 768111, ~: 770064)
-RainterpreterReferenceExternIntIncTest:testRainterpreterReferenceExternIntIncSubParseKnownWord(uint16,bytes1) (runs: 112, μ: 2095525, ~: 2095759)
+RainterpreterReferenceExternIntIncTest:testRainterpreterReferenceExternIntIncRun(bytes32,bytes32[]) (runs: 112, μ: 768290, ~: 770064)
+RainterpreterReferenceExternIntIncTest:testRainterpreterReferenceExternIntIncSubParseKnownWord(uint16,bytes1) (runs: 112, μ: 2095517, ~: 2095759)
 RainterpreterReferenceExternIntIncTest:testRainterpreterReferenceExternIntIncSubParseUnknownWord(uint16,bytes1,bytes) (runs: 101, μ: 2091861, ~: 2091662)
 RainterpreterReferenceExternPointersTest:testIntegrityFunctionPointers() (gas: 2081736)
 RainterpreterReferenceExternPointersTest:testOpcodeFunctionPointers() (gas: 2081779)
@@ -1025,11 +1037,11 @@ RainterpreterReferenceExternPointersTest:testSubParserFunctionPointers() (gas: 2
 RainterpreterReferenceExternPointersTest:testSubParserLiteralParsers() (gas: 2081756)
 RainterpreterReferenceExternPointersTest:testSubParserOperandParsers() (gas: 2082229)
 RainterpreterReferenceExternPointersTest:testSubParserParseMeta() (gas: 22017)
-RainterpreterReferenceExternRepeatTest:testRainterpreterReferenceExternRepeatHappy() (gas: 2213032)
-RainterpreterReferenceExternStackOperandTest:testRainterpreterReferenceExternStackOperandSingle(uint256) (runs: 2060, μ: 2168207, ~: 2168296)
-RainterpreterReferenceExternUnknownWordTest:testRainterpreterReferenceExternUnknownWord() (gas: 2129384)
-RainterpreterStateOverlayTest:testStateOverlayGet() (gas: 52392)
-RainterpreterStateOverlayTest:testStateOverlaySet() (gas: 83131)
+RainterpreterReferenceExternRepeatTest:testRainterpreterReferenceExternRepeatHappy() (gas: 2213046)
+RainterpreterReferenceExternStackOperandTest:testRainterpreterReferenceExternStackOperandSingle(uint256) (runs: 2060, μ: 2168226, ~: 2168303)
+RainterpreterReferenceExternUnknownWordTest:testRainterpreterReferenceExternUnknownWord() (gas: 2129390)
+RainterpreterStateOverlayTest:testStateOverlayGet() (gas: 52398)
+RainterpreterStateOverlayTest:testStateOverlaySet() (gas: 83137)
 RainterpreterStoreIERC165Test:testRainterpreterStoreIERC165(bytes4) (runs: 2060, μ: 229923, ~: 229923)
 RainterpreterStoreTest:testRainterpreterStoreSetGetDupes((uint256,bytes32[11])[]) (runs: 105, μ: 1602851, ~: 1605247)
 RainterpreterStoreTest:testRainterpreterStoreSetGetNoDupesMany((uint256,bytes32[])[]) (runs: 112, μ: 3403233, ~: 3312550)
diff --git a/src/generated/Rainterpreter.pointers.sol b/src/generated/Rainterpreter.pointers.sol
index c2b437fe1..66e4ebf17 100644
--- a/src/generated/Rainterpreter.pointers.sol
+++ b/src/generated/Rainterpreter.pointers.sol
@@ -10,11 +10,11 @@
 pragma solidity =0.8.25;
 
 /// @dev Hash of the known bytecode.
-bytes32 constant BYTECODE_HASH = bytes32(0x9b9b20453f24850d1c938472253c1acccbe7021666425ba792e886b822505c1e);
+bytes32 constant BYTECODE_HASH = bytes32(0x3067cd3ea6ed3bd416a94f05994e24197fbea237f58ebb54c31c455c02c9c578);
 
 /// @dev The function pointers known to the interpreter for dynamic dispatch.
 /// By setting these as a constant they can be inlined into the interpreter
 /// and loaded at eval time for very low gas (~100) due to the compiler
 /// optimising it to a single `codecopy` to build the in memory bytes array.
 bytes constant OPCODE_FUNCTION_POINTERS =
-    hex"082d085f08830a0f0ad80aea0afc0b150b390b6d0b7e0b8f0c310c500d0e0dbe0e420f8410b70d0e11b012621304137c138d139e139e13af141a152515a415bd15d1163016491662169b16c616df16f8171f1732179417e21830187e18cc18da1928197619a719b519c319d11a1f1a501a9e1acf1b001b4e1b7b1bc91cbf";
+    hex"0831086308870a130adc0aee0b000b190b3d0b710b820b930c350c540d120dc20e460f8810bb0d1211b4126613081380139113a213a213b3141e152915a815c115d51634164d1666169f16ca16e316fc17231736179817e61834188218d018de192c197a19ab19b919c719d51a231a541a851ad31b041b351b831bb01bfe1cf4";
diff --git a/src/generated/RainterpreterExpressionDeployer.pointers.sol b/src/generated/RainterpreterExpressionDeployer.pointers.sol
index bd01d605f..2de4954e0 100644
--- a/src/generated/RainterpreterExpressionDeployer.pointers.sol
+++ b/src/generated/RainterpreterExpressionDeployer.pointers.sol
@@ -10,11 +10,11 @@
 pragma solidity =0.8.25;
 
 /// @dev Hash of the known bytecode.
-bytes32 constant BYTECODE_HASH = bytes32(0x4ef7c853b89f77ce1a7971776d915b41629ff5e10f484f98cd08cd83a7dd3ef8);
+bytes32 constant BYTECODE_HASH = bytes32(0xe31030f8cd9295c31787bc462f4a710eb6ffd3b3acc358eb126ef96540cd56b4);
 
 /// @dev The hash of the meta that describes the contract.
-bytes32 constant DESCRIBED_BY_META_HASH = bytes32(0x613f064185488d58a0657d4ae05e051bb3ce748710183cac48ccdbd0dda92dc2);
+bytes32 constant DESCRIBED_BY_META_HASH = bytes32(0xd80b1ab409ece8a0cc8b7cf98b80d67805b2cfdafeeee1797fdb999edd8ba1dd);
 
 /// @dev The function pointers for the integrity check fns.
 bytes constant INTEGRITY_FUNCTION_POINTERS =
-    hex"0eb00f2e0f92110c1116111611201129114411ea11ea124612be12cb1116112012cb111611201116111611161120110c110c110c110c12d512fa13141116111612d51116111612cb11201116111612cb110c131e131e131e131e131e1120131e1338110c112011201120131e110c131e110c110c13381116133811201314";
+    hex"0eb80f360f9a1114111e111e11281131114c11f211f2124e12c612d3111e112812d3111e1128111e111e111e1128111411141114111412dd1302131c111e111e12dd111e111e12d31128111e111e12d311141326132613261326132611281326134011141128112811281326111411141326111411141340111e13401128131c";
diff --git a/src/generated/RainterpreterParser.pointers.sol b/src/generated/RainterpreterParser.pointers.sol
index 6b4f5689e..ba3bab281 100644
--- a/src/generated/RainterpreterParser.pointers.sol
+++ b/src/generated/RainterpreterParser.pointers.sol
@@ -10,7 +10,7 @@
 pragma solidity =0.8.25;
 
 /// @dev Hash of the known bytecode.
-bytes32 constant BYTECODE_HASH = bytes32(0xd5cd8849e7e3c4650918b70132781e569b948577b1ee29fd7b02893bcf088646);
+bytes32 constant BYTECODE_HASH = bytes32(0x81b9d86cfe33dbfd1bfc4f9fcbe240b785ffac59ee86533e175590c227f8538d);
 
 /// @dev The parse meta that is used to lookup word definitions.
 /// The structure of the parse meta is:
@@ -29,7 +29,7 @@ bytes32 constant BYTECODE_HASH = bytes32(0xd5cd8849e7e3c4650918b70132781e569b948
 /// bit count of the previous bloom filter. If we reach the end of the bloom
 /// filters then we have a miss.
 bytes constant PARSE_META =
-    hex"02192ac782060c081806c6c1900010012220200283045069000114680901208401260000000000000000000000000000000000000000001000000000000000000000202c49b09d200441910d1e98a7329c08461fd6ea18118eba9713065d3029ab10ec04ac72c00e7ff5a23eae0c8706fb9c253dc7bc2333acb2941b0b5fc712fec72818d295ed35d9a6c50063d58d34dd44c9261df07b39cb6609012ba09831d9776c0c6cbb422f6d6b2403ae6396082c4e962787daec2841d78a16172ab51a5b8f1d1c2d57c43bca85c615f871180f48502f25b9d38d0be7f2e71ef1ff4d19d140c23c1a1e3510abcc6405b702d7020f038b2a93067d220df2ef07ee624a214143471482e75b1d60aa350a3d21ff174c80cb30cc4a6a3a023c042ba9578e360cdb6909a046dc38d89c342ed4e3cf233bc325379b388724b25e682d7b09ff";
+    hex"02192ac782060c081806c6c1900010012220200283045069400114680901208401260000000000000000000000000000000000000000001000000000000000000000202c49b09d200441910d1e98a7329c08461fd6ea18118eba9713065d3029ab10ec04ac72c00e7ff5a23fae0c8706fb9c253ec7bc2333acb2941b0b5fc712fec72836e7c86c18d295ed35d9a6c50063d58d34dd44c9261df07b3acb6609012ba09831d9776c0c6cbb422f6d6b2403ae6396082c4e962787daec2841d78a16172ab51a5b8f1d1c2d57c43cca85c615f871180f48502f25b9d38d0be7f2e71ef1ff4d19d140c23d1a1e3510abcc6405b702d7020f038b2a93067d220df2ef07ee624a214143471482e75b1d60aa350a3d21ff174c80cb30cc4a6a3b023c042ba9578e370cdb6909a046dc39d89c342ed4e3cf233bc325389b388724b25e682d7b09ff";
 
 /// @dev The build depth of the parser meta.
 
@@ -39,11 +39,11 @@ uint8 constant PARSE_META_BUILD_DEPTH = 2;
 /// These positional indexes all map to the same indexes looked up in the parse
 /// meta.
 bytes constant OPERAND_HANDLER_FUNCTION_POINTERS =
-    hex"1a951a951a951b6a1c811c811c811b6a1b6a1a951a951a951c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811c811a951c811c81";
+    hex"1a9d1a9d1a9d1b721c891c891c891b721b721a9d1a9d1a9d1c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891c891a9d1c891c89";
 
 /// @dev Every two bytes is a function pointer for a literal parser.
 /// Literal dispatches are determined by the first byte(s) of the literal
 /// rather than a full word lookup, and are done with simple conditional
 /// jumps as the possibilities are limited compared to the number of words we
 /// have.
-bytes constant LITERAL_PARSER_FUNCTION_POINTERS = hex"15dd180f185218f0";
+bytes constant LITERAL_PARSER_FUNCTION_POINTERS = hex"15e51817185a18f8";
diff --git a/src/lib/op/LibAllStandardOps.sol b/src/lib/op/LibAllStandardOps.sol
index f35fa1b42..4e1f7d236 100644
--- a/src/lib/op/LibAllStandardOps.sol
+++ b/src/lib/op/LibAllStandardOps.sol
@@ -86,6 +86,7 @@ import {LibOpInv} from "./math/LibOpInv.sol";
 // import {LibOpLn} from "./math/LibOpLn.sol";
 // import {LibOpLog10} from "./math/LibOpLog10.sol";
 import {LibOpMax} from "./math/LibOpMax.sol";
+import {LibOpMaxNegativeValue} from "./math/LibOpMaxNegativeValue.sol";
 import {LibOpMaxPositiveValue} from "./math/LibOpMaxPositiveValue.sol";
 import {LibOpMin} from "./math/LibOpMin.sol";
 import {LibOpMinNegativeValue} from "./math/LibOpMinNegativeValue.sol";
@@ -111,7 +112,7 @@ import {LibParseLiteralHex} from "../parse/literal/LibParseLiteralHex.sol";
 import {LibParseLiteralSubParseable} from "../parse/literal/LibParseLiteralSubParseable.sol";
 
 /// @dev Number of ops currently provided by `AllStandardOps`.
-uint256 constant ALL_STANDARD_OPS_LENGTH = 63;
+uint256 constant ALL_STANDARD_OPS_LENGTH = 64;
 
 /// @title LibAllStandardOps
 /// @notice Every opcode available from the core repository laid out as a single
@@ -286,6 +287,10 @@ library LibAllStandardOps {
             // AuthoringMetaV2("log2", "Base 2 logarithm log2(x). Errors if the number is zero."),
             // AuthoringMetaV2("log10", "Base 10 logarithm log10(x). Errors if the number is zero."),
             AuthoringMetaV2("max", "Finds the maximum number from all inputs."),
+            AuthoringMetaV2(
+                "max-negative-value",
+                "The maximum representable float value that is negative. This is the largest number that can be represented that is still less than zero."
+            ),
             AuthoringMetaV2(
                 "max-positive-value",
                 "The maximum representable float value. This is so large that it is effectively infinity. Almost all numbers that you could possibly subtract from it will be ignored as a rounding error."
@@ -489,6 +494,8 @@ library LibAllStandardOps {
                     // LibParseOperand.handleOperandDisallowed,
                     // max
                     LibParseOperand.handleOperandDisallowed,
+                    // max-negative-value
+                    LibParseOperand.handleOperandDisallowed,
                     // max-positive-value
                     LibParseOperand.handleOperandDisallowed,
                     // min
@@ -608,6 +615,7 @@ library LibAllStandardOps {
                     // LibOpLog2.integrity,
                     // LibOpLog10.integrity,
                     LibOpMax.integrity,
+                    LibOpMaxNegativeValue.integrity,
                     LibOpMaxPositiveValue.integrity,
                     LibOpMin.integrity,
                     LibOpMinNegativeValue.integrity,
@@ -718,6 +726,7 @@ library LibAllStandardOps {
                     // LibOpLog2.run,
                     // LibOpLog10.run,
                     LibOpMax.run,
+                    LibOpMaxNegativeValue.run,
                     LibOpMaxPositiveValue.run,
                     LibOpMin.run,
                     LibOpMinNegativeValue.run,
diff --git a/src/lib/op/math/LibOpMaxNegativeValue.sol b/src/lib/op/math/LibOpMaxNegativeValue.sol
new file mode 100644
index 000000000..59b88ad82
--- /dev/null
+++ b/src/lib/op/math/LibOpMaxNegativeValue.sol
@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: CAL
+pragma solidity ^0.8.18;
+
+import {IntegrityCheckState} from "../../integrity/LibIntegrityCheck.sol";
+import {OperandV2, StackItem} from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol";
+import {InterpreterState} from "../../state/LibInterpreterState.sol";
+import {Pointer} from "rain.solmem/lib/LibPointer.sol";
+import {Float, LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol";
+
+/// @title LibOpMaxNegativeValue
+/// Exposes the maximum negative representable float value as a Rainlang opcode.
+library LibOpMaxNegativeValue {
+    using LibDecimalFloat for Float;
+
+    function integrity(IntegrityCheckState memory, OperandV2) internal pure returns (uint256, uint256) {
+        return (0, 1);
+    }
+
+    function run(InterpreterState memory, OperandV2, Pointer stackTop) internal pure returns (Pointer) {
+        Float value = LibDecimalFloat.FLOAT_MAX_NEGATIVE_VALUE;
+        assembly ("memory-safe") {
+            stackTop := sub(stackTop, 0x20)
+            mstore(stackTop, value)
+        }
+        return stackTop;
+    }
+
+    function referenceFn(InterpreterState memory, OperandV2, StackItem[] memory)
+        internal
+        pure
+        returns (StackItem[] memory)
+    {
+        StackItem[] memory outputs = new StackItem[](1);
+        outputs[0] = StackItem.wrap(Float.unwrap(LibDecimalFloat.packLossless(-1, type(int32).min)));
+        return outputs;
+    }
+}
diff --git a/test/src/lib/op/math/LibOpAdd.t.sol b/test/src/lib/op/math/LibOpAdd.t.sol
index b4543500d..359fed394 100644
--- a/test/src/lib/op/math/LibOpAdd.t.sol
+++ b/test/src/lib/op/math/LibOpAdd.t.sol
@@ -122,25 +122,25 @@ contract LibOpAddTest is OpTest {
     }
 
     /// Test the eval of `add` opcode parsed from a string. Tests two inputs.
-    /// Tests that adding 0 to max-value() is max-value().
+    /// Tests that adding 0 to max-positive-value() is max-positive-value().
     function testOpAddEval2InputsHappyZeroMax() external view {
         checkHappy(
-            "_: add(0 max-value());",
+            "_: add(0 max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "0 + max-value()"
+            "0 + max-positive-value()"
         );
         checkHappy(
-            "_: add(max-value() 0);",
+            "_: add(max-positive-value() 0);",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "max-value() + 0"
+            "max-positive-value() + 0"
         );
     }
 
     /// Test the eval of `add` opcode parsed from a string. Tests two inputs.
     /// Tests the unhappy path where the addition does overflow.
     function testOpAddEval2InputsUnhappy() external {
-        checkUnhappyOverflow("_: add(max-value() 1e-18);", 13479973333575319897333507543509815336, 2147483677);
-        checkUnhappyOverflow("_: add(1e-18 max-value());", 13479973333575319897333507543509815336, 2147483677);
+        checkUnhappyOverflow("_: add(max-positive-value() 1e-18);", 13479973333575319897333507543509815336, 2147483677);
+        checkUnhappyOverflow("_: add(1e-18 max-positive-value());", 13479973333575319897333507543509815336, 2147483677);
     }
 
     /// Test the eval of `add` opcode parsed from a string. Tests three inputs.
@@ -156,27 +156,53 @@ contract LibOpAddTest is OpTest {
     /// Test the eval of `add` opcode parsed from a string. Tests three inputs.
     /// Tests the unhappy path where the addition does overflow.
     function testOpAddEval3InputsUnhappy() external {
-        checkUnhappyOverflow("_: add(max-value() 1e-18 1e-18);", 13479973333575319897333507543509815336, 2147483677);
-        checkUnhappyOverflow("_: add(1e-18 max-value() 1e-18);", 13479973333575319897333507543509815336, 2147483677);
-        checkUnhappyOverflow("_: add(1e-18 1e-18 max-value());", 13479973333575319897333507543509815336, 2147483677);
         checkUnhappyOverflow(
-            "_: add(max-value() max-value() 1e-18);", 26959946667150639794667015087019630672, 2147483677
+            "_: add(max-positive-value() 1e-18 1e-18);", 13479973333575319897333507543509815336, 2147483677
         );
         checkUnhappyOverflow(
-            "_: add(max-value() 1e-18 max-value());", 13479973333575319897333507543509815336, 2147483677
+            "_: add(1e-18 max-positive-value() 1e-18);", 13479973333575319897333507543509815336, 2147483677
         );
         checkUnhappyOverflow(
-            "_: add(1e-18 max-value() max-value());", 13479973333575319897333507543509815336, 2147483677
+            "_: add(1e-18 1e-18 max-positive-value());", 13479973333575319897333507543509815336, 2147483677
         );
         checkUnhappyOverflow(
-            "_: add(max-value() max-value() max-value());", 26959946667150639794667015087019630672, 2147483677
+            "_: add(max-positive-value() max-positive-value() 1e-18);",
+            26959946667150639794667015087019630672,
+            2147483677
+        );
+        checkUnhappyOverflow(
+            "_: add(max-positive-value() 1e-18 max-positive-value());",
+            13479973333575319897333507543509815336,
+            2147483677
+        );
+        checkUnhappyOverflow(
+            "_: add(1e-18 max-positive-value() max-positive-value());",
+            13479973333575319897333507543509815336,
+            2147483677
+        );
+        checkUnhappyOverflow(
+            "_: add(max-positive-value() max-positive-value() max-positive-value());",
+            26959946667150639794667015087019630672,
+            2147483677
+        );
+        checkUnhappyOverflow(
+            "_: add(max-positive-value() 1e-18 0);", 13479973333575319897333507543509815336, 2147483677
+        );
+        checkUnhappyOverflow(
+            "_: add(1e-18 max-positive-value() 0);", 13479973333575319897333507543509815336, 2147483677
+        );
+        checkUnhappyOverflow(
+            "_: add(1e-18 0 max-positive-value());", 13479973333575319897333507543509815336, 2147483677
+        );
+        checkUnhappyOverflow(
+            "_: add(max-positive-value() max-positive-value() 0);", 26959946667150639794667015087019630672, 2147483677
+        );
+        checkUnhappyOverflow(
+            "_: add(max-positive-value() 0 max-positive-value());", 26959946667150639794667015087019630672, 2147483677
+        );
+        checkUnhappyOverflow(
+            "_: add(0 max-positive-value() max-positive-value());", 26959946667150639794667015087019630672, 2147483677
         );
-        checkUnhappyOverflow("_: add(max-value() 1e-18 0);", 13479973333575319897333507543509815336, 2147483677);
-        checkUnhappyOverflow("_: add(1e-18 max-value() 0);", 13479973333575319897333507543509815336, 2147483677);
-        checkUnhappyOverflow("_: add(1e-18 0 max-value());", 13479973333575319897333507543509815336, 2147483677);
-        checkUnhappyOverflow("_: add(max-value() max-value() 0);", 26959946667150639794667015087019630672, 2147483677);
-        checkUnhappyOverflow("_: add(max-value() 0 max-value());", 26959946667150639794667015087019630672, 2147483677);
-        checkUnhappyOverflow("_: add(0 max-value() max-value());", 26959946667150639794667015087019630672, 2147483677);
     }
 
     /// Test the eval of `add` opcode parsed from a string.
diff --git a/test/src/lib/op/math/LibOpDiv.t.sol b/test/src/lib/op/math/LibOpDiv.t.sol
index 620e3af9f..3914a8d55 100644
--- a/test/src/lib/op/math/LibOpDiv.t.sol
+++ b/test/src/lib/op/math/LibOpDiv.t.sol
@@ -105,7 +105,7 @@ contract LibOpDivTest is OpTest {
         checkBadInputs("_: div(5);", 1, 2, 1);
         checkBadInputs("_: div(0);", 1, 2, 1);
         checkBadInputs("_: div(1);", 1, 2, 1);
-        checkBadInputs("_: div(max-value());", 1, 2, 1);
+        checkBadInputs("_: div(max-positive-value());", 1, 2, 1);
     }
 
     /// Test the eval of `div` opcode parsed from a string.
@@ -119,7 +119,7 @@ contract LibOpDivTest is OpTest {
         checkHappy("_: div(2 2);", Float.unwrap(LibDecimalFloat.packLossless(1e38, -38)), "2 2");
         checkHappy("_: div(2 0.1);", Float.unwrap(LibDecimalFloat.packLossless(2e38, -37)), "2 0.1");
         // https://github.com/rainlanguage/rain.math.float/issues/71
-        // checkHappy("_: div(max-value() 1);", Float.unwrap(LibDecimalFloat.packLossless(1, 1)), "max-value() 1");
+        // checkHappy("_: div(max-positive-value() 1);", Float.unwrap(LibDecimalFloat.packLossless(1, 1)), "max-positive-value() 1");
     }
 
     /// Test the eval of `div` opcode parsed from a string.
@@ -128,14 +128,14 @@ contract LibOpDivTest is OpTest {
     function testOpDivEvalTwoInputsUnhappy() external {
         checkUnhappy("_: div(0 0);", stdError.divisionError);
         checkUnhappy("_: div(1 0);", stdError.divisionError);
-        checkUnhappy("_: div(max-value() 0);", stdError.divisionError);
+        checkUnhappy("_: div(max-positive-value() 0);", stdError.divisionError);
     }
 
     /// Test the eval of `div` opcode parsed from a string.
     /// Tests two inputs.
     /// Tests the unhappy path where the final result overflows.
     function testOpDivEvalTwoInputsUnhappyOverflow() external {
-        checkUnhappyOverflow("_: div(max-value() 1e-18);", 134799733335753198973335075435098153360, 2147483694);
+        checkUnhappyOverflow("_: div(max-positive-value() 1e-18);", 134799733335753198973335075435098153360, 2147483694);
         // checkUnhappy("_: div(1e52 1e-8);", abi.encodeWithSelector(PRBMath_MulDiv_Overflow.selector, 1e70, 1e18, 1e10));
     }
 
@@ -150,7 +150,7 @@ contract LibOpDivTest is OpTest {
         checkHappy("_: div(1 2 2);", Float.unwrap(LibDecimalFloat.packLossless(25e37, -39)), "1 2 2");
         checkHappy("_: div(1 2 0.1);", Float.unwrap(LibDecimalFloat.packLossless(5e38, -38)), "1 2 0.1");
         // https://github.com/rainlanguage/rain.math.float/issues/71
-        // checkHappy("_: div(max-value() 1 1);", type(uint256).max, "max-value() 1 1");
+        // checkHappy("_: div(max-positive-value() 1 1);", type(uint256).max, "max-positive-value() 1 1");
     }
 
     /// Test the eval of `div` opcode parsed from a string.
@@ -160,14 +160,16 @@ contract LibOpDivTest is OpTest {
         checkUnhappy("_: div(0 0 0);", stdError.divisionError);
         checkUnhappy("_: div(1 0 0);", stdError.divisionError);
         checkUnhappy("_: div(1 1 0);", stdError.divisionError);
-        checkUnhappy("_: div(max-value() 0 0);", stdError.divisionError);
+        checkUnhappy("_: div(max-positive-value() 0 0);", stdError.divisionError);
     }
 
     /// Test the eval of `div` opcode parsed from a string.
     /// Tests three inputs.
     /// Tests the unhappy path where the final result overflows.
     function testOpDivEvalThreeInputsUnhappyOverflow() external {
-        checkUnhappyOverflow("_: div(max-value() 1e-18 1e-18);", 134799733335753198973335075435098153360, 2147483694);
+        checkUnhappyOverflow(
+            "_: div(max-positive-value() 1e-18 1e-18);", 134799733335753198973335075435098153360, 2147483694
+        );
         // checkUnhappyOverflow("_: div(1e900000000 1 1e-900000000);", 1, -8000000000000000000000000000);
         //         checkUnhappy("_: div(1e52 1e-8 1);", abi.encodeWithSelector(PRBMath_MulDiv_Overflow.selector, 1e70, 1e18, 1e10));
     }
diff --git a/test/src/lib/op/math/LibOpMax.t.sol b/test/src/lib/op/math/LibOpMax.t.sol
index af9882a76..486415856 100644
--- a/test/src/lib/op/math/LibOpMax.t.sol
+++ b/test/src/lib/op/math/LibOpMax.t.sol
@@ -62,7 +62,7 @@ contract LibOpMaxTest is OpTest {
         checkBadInputs("_: max(5e-18);", 1, 2, 1);
         checkBadInputs("_: max(0);", 1, 2, 1);
         checkBadInputs("_: max(1e-18);", 1, 2, 1);
-        checkBadInputs("_: max(max-value());", 1, 2, 1);
+        checkBadInputs("_: max(max-positive-value());", 1, 2, 1);
     }
 
     function testOpMaxEvalTwoOutputs() external {
@@ -74,31 +74,31 @@ contract LibOpMaxTest is OpTest {
         checkHappy("_: max(0 0);", 0, "0 > 0 ? 0 : 1");
         checkHappy("_: max(1 0);", Float.unwrap(LibDecimalFloat.packLossless(1, 0)), "1 > 0 ? 1 : 0");
         checkHappy(
-            "_: max(max-value() 0);",
+            "_: max(max-positive-value() 0);",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "max-value() > 0 ? max-value() : 0"
+            "max-positive-value() > 0 ? max-positive-value() : 0"
         );
         checkHappy("_: max(0 1);", Float.unwrap(LibDecimalFloat.packLossless(1, 0)), "0 > 1 ? 0 : 1");
         checkHappy("_: max(1 1);", Float.unwrap(LibDecimalFloat.packLossless(1, 0)), "1 > 1 ? 1 : 1");
         checkHappy(
-            "_: max(0 max-value());",
+            "_: max(0 max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "0 > max-value() ? 0 : max-value()"
+            "0 > max-positive-value() ? 0 : max-positive-value()"
         );
         checkHappy(
-            "_: max(1 max-value());",
+            "_: max(1 max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "1 > max-value() ? 1 : max-value()"
+            "1 > max-positive-value() ? 1 : max-positive-value()"
         );
         checkHappy(
-            "_: max(max-value() 1);",
+            "_: max(max-positive-value() 1);",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "1 > max-value() ? 1 : max-value()"
+            "1 > max-positive-value() ? 1 : max-positive-value()"
         );
         checkHappy(
-            "_: max(max-value() max-value());",
+            "_: max(max-positive-value() max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "max-value() > max-value() ? max-value() : max-value()"
+            "max-positive-value() > max-positive-value() ? max-positive-value() : max-positive-value()"
         );
         checkHappy("_: max(0 2);", Float.unwrap(LibDecimalFloat.packLossless(2, 0)), "0 > 2 ? 0 : 2");
         checkHappy("_: max(1 2);", Float.unwrap(LibDecimalFloat.packLossless(2, 0)), "1 > 2 ? 1 : 2");
@@ -142,49 +142,49 @@ contract LibOpMaxTest is OpTest {
         checkHappy("_: max(1 2 2);", Float.unwrap(LibDecimalFloat.packLossless(2, 0)), "1 2 2");
         checkHappy("_: max(2 2 2);", Float.unwrap(LibDecimalFloat.packLossless(2, 0)), "2 2 2");
         checkHappy(
-            "_: max(0 0 max-value());",
+            "_: max(0 0 max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "0 0 max-value()"
+            "0 0 max-positive-value()"
         );
         checkHappy(
-            "_: max(1 0 max-value());",
+            "_: max(1 0 max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "1 0 max-value()"
+            "1 0 max-positive-value()"
         );
         checkHappy(
-            "_: max(2 0 max-value());",
+            "_: max(2 0 max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "2 0 max-value()"
+            "2 0 max-positive-value()"
         );
         checkHappy(
-            "_: max(0 1 max-value());",
+            "_: max(0 1 max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "0 1 max-value()"
+            "0 1 max-positive-value()"
         );
         checkHappy(
-            "_: max(1 1 max-value());",
+            "_: max(1 1 max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "1 1 max-value()"
+            "1 1 max-positive-value()"
         );
         checkHappy(
-            "_: max(2 1 max-value());",
+            "_: max(2 1 max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "2 1 max-value()"
+            "2 1 max-positive-value()"
         );
         checkHappy(
-            "_: max(0 2 max-value());",
+            "_: max(0 2 max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "0 2 max-value()"
+            "0 2 max-positive-value()"
         );
         checkHappy(
-            "_: max(1 2 max-value());",
+            "_: max(1 2 max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "1 2 max-value()"
+            "1 2 max-positive-value()"
         );
         checkHappy(
-            "_: max(2 2 max-value());",
+            "_: max(2 2 max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "2 2 max-value()"
+            "2 2 max-positive-value()"
         );
         checkHappy("_: max(-1.1 -1.0 0);", Float.unwrap(LibDecimalFloat.packLossless(0, 0)), "-1.1 -1.0 0");
         checkHappy("_: max(-1.0 -1 0);", Float.unwrap(LibDecimalFloat.packLossless(0, 0)), "-1.0 -1 0");
diff --git a/test/src/lib/op/math/LibOpMaxNegativeValue.t.sol b/test/src/lib/op/math/LibOpMaxNegativeValue.t.sol
new file mode 100644
index 000000000..c5d9327f3
--- /dev/null
+++ b/test/src/lib/op/math/LibOpMaxNegativeValue.t.sol
@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: CAL
+pragma solidity =0.8.25;
+
+import {OpTest} from "test/abstract/OpTest.sol";
+import {LibOpMaxNegativeValue} from "src/lib/op/math/LibOpMaxNegativeValue.sol";
+import {IntegrityCheckState, BadOpInputsLength} from "src/lib/integrity/LibIntegrityCheck.sol";
+import {
+    IInterpreterV4,
+    OperandV2,
+    SourceIndexV2,
+    FullyQualifiedNamespace,
+    StackItem
+} from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol";
+import {InterpreterState, LibInterpreterState} from "src/lib/state/LibInterpreterState.sol";
+import {LibContext} from "rain.interpreter.interface/lib/caller/LibContext.sol";
+import {IInterpreterStoreV2} from "rain.interpreter.interface/interface/IInterpreterStoreV2.sol";
+import {SignedContextV1} from "rain.interpreter.interface/interface/IInterpreterCallerV3.sol";
+import {LibOperand} from "test/lib/operand/LibOperand.sol";
+import {Float, LibDecimalFloat} from "rain.math.float/lib/LibDecimalFloat.sol";
+
+/// @title LibOpMaxNegativeValueTest
+/// @notice Test the runtime and integrity time logic of LibOpMaxNegativeValue.
+contract LibOpMaxNegativeValueTest is OpTest {
+    using LibInterpreterState for InterpreterState;
+    using LibDecimalFloat for Float;
+
+    /// Directly test the integrity logic of LibOpMaxNegativeValue.
+    function testOpMaxValueIntegrity(IntegrityCheckState memory state, uint8 inputs, uint8 outputs, uint16 operandData)
+        external
+        pure
+    {
+        inputs = uint8(bound(inputs, 0, 0x0F));
+        outputs = uint8(bound(outputs, 0, 0x0F));
+        (uint256 calcInputs, uint256 calcOutputs) =
+            LibOpMaxNegativeValue.integrity(state, LibOperand.build(inputs, outputs, operandData));
+
+        assertEq(calcInputs, 0);
+        assertEq(calcOutputs, 1);
+    }
+
+    /// Directly test the runtime logic of LibOpMaxNegativeValue. This tests that
+    /// the opcode correctly pushes the max value onto the stack.
+    function testOpMaxNegativeValueRun() external view {
+        InterpreterState memory state = opTestDefaultInterpreterState();
+        StackItem[] memory inputs = new StackItem[](0);
+        OperandV2 operand = LibOperand.build(0, 1, 0);
+        opReferenceCheck(
+            state,
+            operand,
+            LibOpMaxNegativeValue.referenceFn,
+            LibOpMaxNegativeValue.integrity,
+            LibOpMaxNegativeValue.run,
+            inputs
+        );
+    }
+
+    /// Test the eval of LibOpMaxNegativeValue parsed from a string.
+    function testOpMaxNegativeValueEval() external view {
+        checkHappy("_: max-negative-value();", Float.unwrap(LibDecimalFloat.FLOAT_MAX_NEGATIVE_VALUE), "");
+    }
+
+    /// Test that a max-negative-value with inputs fails integrity check.
+    function testOpMaxNegativeValueEvalFail() public {
+        vm.expectRevert(abi.encodeWithSelector(BadOpInputsLength.selector, 1, 0, 1));
+        bytes memory bytecode = iDeployer.parse2("_: max-negative-value(0x00);");
+        (bytecode);
+    }
+
+    function testOpMaxNegativeValueZeroOutputs() external {
+        checkBadOutputs(": max-negative-value();", 0, 1, 0);
+    }
+
+    function testOpMaxNegativeValueTwoOutputs() external {
+        checkBadOutputs("_ _: max-negative-value();", 0, 1, 2);
+    }
+}
diff --git a/test/src/lib/op/math/LibOpMin.t.sol b/test/src/lib/op/math/LibOpMin.t.sol
index 2cb468b5a..4ea0b3768 100644
--- a/test/src/lib/op/math/LibOpMin.t.sol
+++ b/test/src/lib/op/math/LibOpMin.t.sol
@@ -59,31 +59,31 @@ contract LibOpMinTest is OpTest {
         checkBadInputs("_: min(5);", 1, 2, 1);
         checkBadInputs("_: min(0);", 1, 2, 1);
         checkBadInputs("_: min(1);", 1, 2, 1);
-        checkBadInputs("_: min(max-value());", 1, 2, 1);
+        checkBadInputs("_: min(max-positive-value());", 1, 2, 1);
     }
 
     /// Test the eval of `min` opcode parsed from a string. Tests two inputs.
     function testOpMinEval2InputsHappy() external view {
         checkHappy("_: min(0 0);", 0, "0 > 0 ? 0 : 1");
         checkHappy("_: min(1 0);", 0, "1 > 0 ? 1 : 0");
-        checkHappy("_: min(max-value() 0);", 0, "max-value() > 0 ? max-value() : 0");
+        checkHappy("_: min(max-positive-value() 0);", 0, "max-positive-value() > 0 ? max-positive-value() : 0");
         checkHappy("_: min(0 1);", 0, "0 > 1 ? 0 : 1");
         checkHappy("_: min(1 1);", Float.unwrap(LibDecimalFloat.packLossless(1, 0)), "1 > 1 ? 1 : 1");
-        checkHappy("_: min(0 max-value());", 0, "0 > max-value() ? 0 : max-value()");
+        checkHappy("_: min(0 max-positive-value());", 0, "0 > max-positive-value() ? 0 : max-positive-value()");
         checkHappy(
-            "_: min(1 max-value());",
+            "_: min(1 max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(1, 0)),
-            "1 > max-value() ? 1 : max-value()"
+            "1 > max-positive-value() ? 1 : max-positive-value()"
         );
         checkHappy(
-            "_: min(max-value() 1);",
+            "_: min(max-positive-value() 1);",
             Float.unwrap(LibDecimalFloat.packLossless(1, 0)),
-            "1 > max-value() ? 1 : max-value()"
+            "1 > max-positive-value() ? 1 : max-positive-value()"
         );
         checkHappy(
-            "_: min(max-value() max-value());",
+            "_: min(max-positive-value() max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "max-value() > max-value() ? max-value() : max-value()"
+            "max-positive-value() > max-positive-value() ? max-positive-value() : max-positive-value()"
         );
         checkHappy("_: min(0 2);", 0, "0 > 2 ? 0 : 2");
         checkHappy("_: min(1 2);", Float.unwrap(LibDecimalFloat.packLossless(1, 0)), "1 > 2 ? 1 : 2");
@@ -130,70 +130,124 @@ contract LibOpMinTest is OpTest {
         checkHappy("_: min(0 2 2);", 0, "0 2 2");
         checkHappy("_: min(1 2 2);", Float.unwrap(LibDecimalFloat.packLossless(1, 0)), "1 2 2");
         checkHappy("_: min(2 2 2);", Float.unwrap(LibDecimalFloat.packLossless(2, 0)), "2 2 2");
-        checkHappy("_: min(0 0 max-value());", 0, "0 0 max-value()");
-        checkHappy("_: min(1 0 max-value());", 0, "1 0 max-value()");
-        checkHappy("_: min(2 0 max-value());", 0, "2 0 max-value()");
-        checkHappy("_: min(0 1 max-value());", 0, "0 1 max-value()");
-        checkHappy("_: min(1 1 max-value());", Float.unwrap(LibDecimalFloat.packLossless(1, 0)), "1 1 max-value()");
-        checkHappy("_: min(2 1 max-value());", Float.unwrap(LibDecimalFloat.packLossless(1, 0)), "2 1 max-value()");
-        checkHappy("_: min(0 2 max-value());", 0, "0 2 max-value()");
-        checkHappy("_: min(1 2 max-value());", Float.unwrap(LibDecimalFloat.packLossless(1, 0)), "1 2 max-value()");
-        checkHappy("_: min(2 2 max-value());", Float.unwrap(LibDecimalFloat.packLossless(2, 0)), "2 2 max-value()");
-        checkHappy("_: min(0 max-value() 0);", 0, "0 max-value() 0");
-        checkHappy("_: min(1 max-value() 0);", 0, "1 max-value() 0");
-        checkHappy("_: min(2 max-value() 0);", 0, "2 max-value() 0");
-        checkHappy("_: min(0 max-value() 1);", 0, "0 max-value() 1");
-        checkHappy("_: min(1 max-value() 1);", Float.unwrap(LibDecimalFloat.packLossless(1, 0)), "1 max-value() 1");
-        checkHappy("_: min(2 max-value() 1);", Float.unwrap(LibDecimalFloat.packLossless(1, 0)), "2 max-value() 1");
-        checkHappy("_: min(0 max-value() 2);", 0, "0 max-value() 2");
-        checkHappy("_: min(1 max-value() 2);", Float.unwrap(LibDecimalFloat.packLossless(1, 0)), "1 max-value() 2");
-        checkHappy("_: min(2 max-value() 2);", Float.unwrap(LibDecimalFloat.packLossless(2, 0)), "2 max-value() 2");
-        checkHappy("_: min(0 max-value() max-value());", 0, "0 max-value() max-value()");
-        checkHappy(
-            "_: min(1 max-value() max-value());",
+        checkHappy("_: min(0 0 max-positive-value());", 0, "0 0 max-positive-value()");
+        checkHappy("_: min(1 0 max-positive-value());", 0, "1 0 max-positive-value()");
+        checkHappy("_: min(2 0 max-positive-value());", 0, "2 0 max-positive-value()");
+        checkHappy("_: min(0 1 max-positive-value());", 0, "0 1 max-positive-value()");
+        checkHappy(
+            "_: min(1 1 max-positive-value());",
+            Float.unwrap(LibDecimalFloat.packLossless(1, 0)),
+            "1 1 max-positive-value()"
+        );
+        checkHappy(
+            "_: min(2 1 max-positive-value());",
+            Float.unwrap(LibDecimalFloat.packLossless(1, 0)),
+            "2 1 max-positive-value()"
+        );
+        checkHappy("_: min(0 2 max-positive-value());", 0, "0 2 max-positive-value()");
+        checkHappy(
+            "_: min(1 2 max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(1, 0)),
-            "1 max-value() max-value()"
+            "1 2 max-positive-value()"
         );
         checkHappy(
-            "_: min(2 max-value() max-value());",
+            "_: min(2 2 max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(2, 0)),
-            "2 max-value() max-value()"
-        );
-        checkHappy("_: min(max-value() 0 0);", 0, "max-value() 0 0");
-        checkHappy("_: min(max-value() 1 0);", 0, "max-value() 1 0");
-        checkHappy("_: min(max-value() 2 0);", 0, "max-value() 2 0");
-        checkHappy("_: min(max-value() 0 1);", 0, "max-value() 0 1");
-        checkHappy("_: min(max-value() 1 1);", Float.unwrap(LibDecimalFloat.packLossless(1, 0)), "max-value() 1 1");
-        checkHappy("_: min(max-value() 2 1);", Float.unwrap(LibDecimalFloat.packLossless(1, 0)), "max-value() 2 1");
-        checkHappy("_: min(max-value() 0 2);", 0, "max-value() 0 2");
-        checkHappy("_: min(max-value() 1 2);", Float.unwrap(LibDecimalFloat.packLossless(1, 0)), "max-value() 1 2");
-        checkHappy("_: min(max-value() 2 2);", Float.unwrap(LibDecimalFloat.packLossless(2, 0)), "max-value() 2 2");
-        checkHappy("_: min(max-value() 0 max-value());", 0, "max-value() 0 max-value()");
-        checkHappy(
-            "_: min(max-value() 1 max-value());",
+            "2 2 max-positive-value()"
+        );
+        checkHappy("_: min(0 max-positive-value() 0);", 0, "0 max-positive-value() 0");
+        checkHappy("_: min(1 max-positive-value() 0);", 0, "1 max-positive-value() 0");
+        checkHappy("_: min(2 max-positive-value() 0);", 0, "2 max-positive-value() 0");
+        checkHappy("_: min(0 max-positive-value() 1);", 0, "0 max-positive-value() 1");
+        checkHappy(
+            "_: min(1 max-positive-value() 1);",
+            Float.unwrap(LibDecimalFloat.packLossless(1, 0)),
+            "1 max-positive-value() 1"
+        );
+        checkHappy(
+            "_: min(2 max-positive-value() 1);",
+            Float.unwrap(LibDecimalFloat.packLossless(1, 0)),
+            "2 max-positive-value() 1"
+        );
+        checkHappy("_: min(0 max-positive-value() 2);", 0, "0 max-positive-value() 2");
+        checkHappy(
+            "_: min(1 max-positive-value() 2);",
+            Float.unwrap(LibDecimalFloat.packLossless(1, 0)),
+            "1 max-positive-value() 2"
+        );
+        checkHappy(
+            "_: min(2 max-positive-value() 2);",
+            Float.unwrap(LibDecimalFloat.packLossless(2, 0)),
+            "2 max-positive-value() 2"
+        );
+        checkHappy(
+            "_: min(0 max-positive-value() max-positive-value());", 0, "0 max-positive-value() max-positive-value()"
+        );
+        checkHappy(
+            "_: min(1 max-positive-value() max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(1, 0)),
-            "max-value() 1 max-value()"
+            "1 max-positive-value() max-positive-value()"
         );
         checkHappy(
-            "_: min(max-value() 2 max-value());",
+            "_: min(2 max-positive-value() max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(2, 0)),
-            "max-value() 2 max-value()"
+            "2 max-positive-value() max-positive-value()"
+        );
+        checkHappy("_: min(max-positive-value() 0 0);", 0, "max-positive-value() 0 0");
+        checkHappy("_: min(max-positive-value() 1 0);", 0, "max-positive-value() 1 0");
+        checkHappy("_: min(max-positive-value() 2 0);", 0, "max-positive-value() 2 0");
+        checkHappy("_: min(max-positive-value() 0 1);", 0, "max-positive-value() 0 1");
+        checkHappy(
+            "_: min(max-positive-value() 1 1);",
+            Float.unwrap(LibDecimalFloat.packLossless(1, 0)),
+            "max-positive-value() 1 1"
+        );
+        checkHappy(
+            "_: min(max-positive-value() 2 1);",
+            Float.unwrap(LibDecimalFloat.packLossless(1, 0)),
+            "max-positive-value() 2 1"
+        );
+        checkHappy("_: min(max-positive-value() 0 2);", 0, "max-positive-value() 0 2");
+        checkHappy(
+            "_: min(max-positive-value() 1 2);",
+            Float.unwrap(LibDecimalFloat.packLossless(1, 0)),
+            "max-positive-value() 1 2"
+        );
+        checkHappy(
+            "_: min(max-positive-value() 2 2);",
+            Float.unwrap(LibDecimalFloat.packLossless(2, 0)),
+            "max-positive-value() 2 2"
+        );
+        checkHappy(
+            "_: min(max-positive-value() 0 max-positive-value());", 0, "max-positive-value() 0 max-positive-value()"
+        );
+        checkHappy(
+            "_: min(max-positive-value() 1 max-positive-value());",
+            Float.unwrap(LibDecimalFloat.packLossless(1, 0)),
+            "max-positive-value() 1 max-positive-value()"
+        );
+        checkHappy(
+            "_: min(max-positive-value() 2 max-positive-value());",
+            Float.unwrap(LibDecimalFloat.packLossless(2, 0)),
+            "max-positive-value() 2 max-positive-value()"
+        );
+        checkHappy(
+            "_: min(max-positive-value() max-positive-value() 0);", 0, "max-positive-value() max-positive-value() 0"
         );
-        checkHappy("_: min(max-value() max-value() 0);", 0, "max-value() max-value() 0");
         checkHappy(
-            "_: min(max-value() max-value() 1);",
+            "_: min(max-positive-value() max-positive-value() 1);",
             Float.unwrap(LibDecimalFloat.packLossless(1, 0)),
-            "max-value() max-value() 1"
+            "max-positive-value() max-positive-value() 1"
         );
         checkHappy(
-            "_: min(max-value() max-value() 2);",
+            "_: min(max-positive-value() max-positive-value() 2);",
             Float.unwrap(LibDecimalFloat.packLossless(2, 0)),
-            "max-value() max-value() 2"
+            "max-positive-value() max-positive-value() 2"
         );
         checkHappy(
-            "_: min(max-value() max-value() max-value());",
+            "_: min(max-positive-value() max-positive-value() max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "max-value() max-value() max-value()"
+            "max-positive-value() max-positive-value() max-positive-value()"
         );
         checkHappy("_: min(0 0 -2);", Float.unwrap(LibDecimalFloat.packLossless(-2, 0)), "0 0 -2");
         checkHappy("_: min(1 0 -2);", Float.unwrap(LibDecimalFloat.packLossless(-2, 0)), "1 0 -2");
diff --git a/test/src/lib/op/math/LibOpMul.t.sol b/test/src/lib/op/math/LibOpMul.t.sol
index 3bb22fbe4..3224706c1 100644
--- a/test/src/lib/op/math/LibOpMul.t.sol
+++ b/test/src/lib/op/math/LibOpMul.t.sol
@@ -74,7 +74,7 @@ contract LibOpMulTest is OpTest {
         checkBadInputs("_: mul(5);", 1, 2, 1);
         checkBadInputs("_: mul(0);", 1, 2, 1);
         checkBadInputs("_: mul(1);", 1, 2, 1);
-        checkBadInputs("_: mul(max-value());", 1, 2, 1);
+        checkBadInputs("_: mul(max-positive-value());", 1, 2, 1);
     }
 
     function testOpMulZeroOutputs() external {
@@ -101,9 +101,9 @@ contract LibOpMulTest is OpTest {
         checkHappy("_: mul(10 10);", Float.unwrap(LibDecimalFloat.packLossless(100, 0)), "10 10");
         // Test an intermediate overflow.
         checkHappy(
-            "_: mul(1 max-value());",
+            "_: mul(1 max-positive-value());",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "1 max-value()"
+            "1 max-positive-value()"
         );
     }
 
@@ -112,7 +112,9 @@ contract LibOpMulTest is OpTest {
     /// Tests the unhappy path where the final result overflows.
     function testOpMulEvalTwoInputsUnhappyOverflow() external {
         checkUnhappyOverflow(
-            "_: mul(max-value() 10);", 13479973333575319897333507543509815336818572211270286240551805124607, 2147483648
+            "_: mul(max-positive-value() 10);",
+            13479973333575319897333507543509815336818572211270286240551805124607,
+            2147483648
         );
     }
 
@@ -135,9 +137,9 @@ contract LibOpMulTest is OpTest {
         checkHappy("_: mul(10 10 10);", Float.unwrap(LibDecimalFloat.packLossless(1000, 0)), "10 10 10");
         // Test an intermediate overflow.
         checkHappy(
-            "_: mul(1 max-value() 1);",
+            "_: mul(1 max-positive-value() 1);",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "1 max-value() 1"
+            "1 max-positive-value() 1"
         );
     }
 
@@ -146,7 +148,7 @@ contract LibOpMulTest is OpTest {
     /// Tests the unhappy path where the final result overflows.
     function testOpMulEvalThreeInputsUnhappyOverflow() external {
         checkUnhappyOverflow(
-            "_: mul(max-value() 1 10);",
+            "_: mul(max-positive-value() 1 10);",
             13479973333575319897333507543509815336818572211270286240551805124607,
             2147483648
         );
diff --git a/test/src/lib/op/math/LibOpSub.t.sol b/test/src/lib/op/math/LibOpSub.t.sol
index 8f905f600..31aa70ce3 100644
--- a/test/src/lib/op/math/LibOpSub.t.sol
+++ b/test/src/lib/op/math/LibOpSub.t.sol
@@ -89,7 +89,7 @@ contract LibOpSubTest is OpTest {
         checkBadInputs("_: sub(5e-18);", 1, 2, 1);
         checkBadInputs("_: sub(0);", 1, 2, 1);
         checkBadInputs("_: sub(1e-18);", 1, 2, 1);
-        checkBadInputs("_: sub(max-value());", 1, 2, 1);
+        checkBadInputs("_: sub(max-positive-value());", 1, 2, 1);
     }
 
     /// Test the eval of `sub` opcode parsed from a string. Tests two inputs.
@@ -99,7 +99,7 @@ contract LibOpSubTest is OpTest {
         checkHappy("_: sub(2 1);", Float.unwrap(LibDecimalFloat.packLossless(1e37, -37)), "2 1");
         checkHappy("_: sub(2 2);", Float.unwrap(LibDecimalFloat.packLossless(0e37, -37)), "2 2");
         checkHappy(
-            "_: sub(max-value() 0);",
+            "_: sub(max-positive-value() 0);",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
             "max-value() 0"
         );
diff --git a/test/src/lib/op/math/uint256/LibOpUint256Div.t.sol b/test/src/lib/op/math/uint256/LibOpUint256Div.t.sol
index 3d7b8c03c..01d5cdf28 100644
--- a/test/src/lib/op/math/uint256/LibOpUint256Div.t.sol
+++ b/test/src/lib/op/math/uint256/LibOpUint256Div.t.sol
@@ -75,7 +75,7 @@ contract LibOpUint256DivTest is OpTest {
         checkBadInputs("_: uint256-div(5e-18);", 1, 2, 1);
         checkBadInputs("_: uint256-div(0e-18);", 1, 2, 1);
         checkBadInputs("_: uint256-div(1e-18);", 1, 2, 1);
-        checkBadInputs("_: uint256-div(max-value());", 1, 2, 1);
+        checkBadInputs("_: uint256-div(max-positive-value());", 1, 2, 1);
     }
 
     function testOpUint256DivEvalZeroOutputs() external {
@@ -179,13 +179,13 @@ contract LibOpUint256DivTest is OpTest {
     function testOpUint256DivEval3InputsUnhappy() external {
         checkUnhappy("_: uint256-div(0 0 0);", stdError.divisionError);
         checkUnhappy("_: uint256-div(1e-18 0 0);", stdError.divisionError);
-        checkUnhappy("_: uint256-div(max-value() 0 0);", stdError.divisionError);
+        checkUnhappy("_: uint256-div(max-positive-value() 0 0);", stdError.divisionError);
         checkUnhappy("_: uint256-div(0 1e-18 0);", stdError.divisionError);
         checkUnhappy("_: uint256-div(1e-18 1e-18 0);", stdError.divisionError);
-        checkUnhappy("_: uint256-div(max-value() max-value() 0);", stdError.divisionError);
+        checkUnhappy("_: uint256-div(max-positive-value() max-positive-value() 0);", stdError.divisionError);
         checkUnhappy("_: uint256-div(0 0 1e-18);", stdError.divisionError);
         checkUnhappy("_: uint256-div(1e-18 0 1e-18);", stdError.divisionError);
-        checkUnhappy("_: uint256-div(max-value() 0 1e-18);", stdError.divisionError);
+        checkUnhappy("_: uint256-div(max-positive-value() 0 1e-18);", stdError.divisionError);
     }
 
     /// Test the eval of `uint256-div` opcode parsed from a string.
diff --git a/test/src/lib/op/math/uint256/LibOpUint256Mul.t.sol b/test/src/lib/op/math/uint256/LibOpUint256Mul.t.sol
index 313bdf0e8..ae3a71508 100644
--- a/test/src/lib/op/math/uint256/LibOpUint256Mul.t.sol
+++ b/test/src/lib/op/math/uint256/LibOpUint256Mul.t.sol
@@ -151,7 +151,7 @@ contract LibOpUint256MulTest is OpTest {
         checkUnhappy("_: uint256-mul(0x02 0x02 uint256-max-value());", stdError.arithmeticError);
         checkUnhappy("_: uint256-mul(uint256-max-value() uint256-max-value() 0x02);", stdError.arithmeticError);
         checkUnhappy("_: uint256-mul(uint256-max-value() 0x02 uint256-max-value());", stdError.arithmeticError);
-        checkUnhappy("_: uint256-mul(2e-18 max-value() max-value());", stdError.arithmeticError);
+        checkUnhappy("_: uint256-mul(2e-18 max-positive-value() max-positive-value());", stdError.arithmeticError);
         checkUnhappy(
             "_: uint256-mul(uint256-max-value() uint256-max-value() uint256-max-value());", stdError.arithmeticError
         );
diff --git a/test/src/lib/op/math/uint256/LibOpUint256Pow.t.sol b/test/src/lib/op/math/uint256/LibOpUint256Pow.t.sol
index 211367782..c7fb8d27f 100644
--- a/test/src/lib/op/math/uint256/LibOpUint256Pow.t.sol
+++ b/test/src/lib/op/math/uint256/LibOpUint256Pow.t.sol
@@ -97,7 +97,7 @@ contract LibOpUint256PowTest is OpTest {
         checkBadInputs("_: uint256-power(5e-18);", 1, 2, 1);
         checkBadInputs("_: uint256-power(0);", 1, 2, 1);
         checkBadInputs("_: uint256-power(1e-18);", 1, 2, 1);
-        checkBadInputs("_: uint256-power(max-value());", 1, 2, 1);
+        checkBadInputs("_: uint256-power(max-positive-value());", 1, 2, 1);
     }
 
     function testOpUint256PowEvalZeroOutputs() external {

From 9847b1578ca0ff807992d8ecc519cf7e52a41dee Mon Sep 17 00:00:00 2001
From: David Meister <thedavidmeister@gmail.com>
Date: Thu, 31 Jul 2025 18:11:02 +0200
Subject: [PATCH 06/10] Update test/src/lib/op/math/LibOpSub.t.sol

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
---
 test/src/lib/op/math/LibOpSub.t.sol | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/src/lib/op/math/LibOpSub.t.sol b/test/src/lib/op/math/LibOpSub.t.sol
index 31aa70ce3..dd3730a45 100644
--- a/test/src/lib/op/math/LibOpSub.t.sol
+++ b/test/src/lib/op/math/LibOpSub.t.sol
@@ -101,7 +101,7 @@ contract LibOpSubTest is OpTest {
         checkHappy(
             "_: sub(max-positive-value() 0);",
             Float.unwrap(LibDecimalFloat.packLossless(type(int224).max, type(int32).max)),
-            "max-value() 0"
+            "max-positive-value() 0"
         );
         checkHappy("_: sub(1 2);", Float.unwrap(LibDecimalFloat.packLossless(-1e37, -37)), "1 2");
         checkHappy("_: sub(1 0.1);", Float.unwrap(LibDecimalFloat.packLossless(9e37, -38)), "1 0.1");

From 933d154931883719fec4666a17398b3ae154f82f Mon Sep 17 00:00:00 2001
From: David Meister <thedavidmeister@gmail.com>
Date: Thu, 31 Jul 2025 18:11:25 +0200
Subject: [PATCH 07/10] Update test/src/lib/op/math/LibOpMinPositiveValue.t.sol

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
---
 test/src/lib/op/math/LibOpMinPositiveValue.t.sol | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/src/lib/op/math/LibOpMinPositiveValue.t.sol b/test/src/lib/op/math/LibOpMinPositiveValue.t.sol
index f219071b0..95bbb4b4a 100644
--- a/test/src/lib/op/math/LibOpMinPositiveValue.t.sol
+++ b/test/src/lib/op/math/LibOpMinPositiveValue.t.sol
@@ -57,7 +57,7 @@ contract LibOpMinPositiveValueTest is OpTest {
     }
 
     /// Test the eval of LibOpMinPositiveValue parsed from a string.
-    function testOpMinPositivepValueEval() external view {
+    function testOpMinPositiveValueEval() external view {
         checkHappy("_: min-positive-value();", Float.unwrap(LibDecimalFloat.FLOAT_MIN_POSITIVE_VALUE), "");
     }
 

From 920163a97e2503a3b5387bf420d714f5763cf386 Mon Sep 17 00:00:00 2001
From: David Meister <thedavidmeister@gmail.com>
Date: Thu, 31 Jul 2025 18:14:45 +0200
Subject: [PATCH 08/10] Update test/src/lib/op/math/LibOpMaxPositiveValue.t.sol

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
---
 test/src/lib/op/math/LibOpMaxPositiveValue.t.sol | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/src/lib/op/math/LibOpMaxPositiveValue.t.sol b/test/src/lib/op/math/LibOpMaxPositiveValue.t.sol
index 85fafe861..5932cc1d1 100644
--- a/test/src/lib/op/math/LibOpMaxPositiveValue.t.sol
+++ b/test/src/lib/op/math/LibOpMaxPositiveValue.t.sol
@@ -55,7 +55,7 @@ contract LibOpMaxPositiveValueTest is OpTest {
     }
 
     /// Test the eval of LibOpMaxPositiveValue parsed from a string.
-    function testOpMaxPositivepValueEval() external view {
+    function testOpMaxPositiveValueEval() external view {
         checkHappy("_: max-positive-value();", Float.unwrap(LibDecimalFloat.FLOAT_MAX_POSITIVE_VALUE), "");
     }
 

From 146d9006c254faa5fb792cd2685ec40c779b82fc Mon Sep 17 00:00:00 2001
From: David Meister <thedavidmeister@gmail.com>
Date: Thu, 31 Jul 2025 18:15:03 +0200
Subject: [PATCH 09/10] Update test/src/lib/op/math/LibOpMaxPositiveValue.t.sol

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>
---
 test/src/lib/op/math/LibOpMaxPositiveValue.t.sol | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/src/lib/op/math/LibOpMaxPositiveValue.t.sol b/test/src/lib/op/math/LibOpMaxPositiveValue.t.sol
index 5932cc1d1..446189ded 100644
--- a/test/src/lib/op/math/LibOpMaxPositiveValue.t.sol
+++ b/test/src/lib/op/math/LibOpMaxPositiveValue.t.sol
@@ -25,7 +25,7 @@ contract LibOpMaxPositiveValueTest is OpTest {
     using LibDecimalFloat for Float;
 
     /// Directly test the integrity logic of LibOpMaxPositiveValue.
-    function testOpMaxValueIntegrity(IntegrityCheckState memory state, uint8 inputs, uint8 outputs, uint16 operandData)
+    function testOpMaxPositiveValueIntegrity(IntegrityCheckState memory state, uint8 inputs, uint8 outputs, uint16 operandData)
         external
         pure
     {

From b428140a5535a4aec81e9e1388fc51a5a41495ec Mon Sep 17 00:00:00 2001
From: thedavidmeister <thedavidmeister@gmail.com>
Date: Thu, 31 Jul 2025 18:27:00 +0200
Subject: [PATCH 10/10] fmt

---
 test/src/lib/op/math/LibOpMaxPositiveValue.t.sol | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/test/src/lib/op/math/LibOpMaxPositiveValue.t.sol b/test/src/lib/op/math/LibOpMaxPositiveValue.t.sol
index 446189ded..a1d4f9969 100644
--- a/test/src/lib/op/math/LibOpMaxPositiveValue.t.sol
+++ b/test/src/lib/op/math/LibOpMaxPositiveValue.t.sol
@@ -25,10 +25,12 @@ contract LibOpMaxPositiveValueTest is OpTest {
     using LibDecimalFloat for Float;
 
     /// Directly test the integrity logic of LibOpMaxPositiveValue.
-    function testOpMaxPositiveValueIntegrity(IntegrityCheckState memory state, uint8 inputs, uint8 outputs, uint16 operandData)
-        external
-        pure
-    {
+    function testOpMaxPositiveValueIntegrity(
+        IntegrityCheckState memory state,
+        uint8 inputs,
+        uint8 outputs,
+        uint16 operandData
+    ) external pure {
         inputs = uint8(bound(inputs, 0, 0x0F));
         outputs = uint8(bound(outputs, 0, 0x0F));
         (uint256 calcInputs, uint256 calcOutputs) =