perf(StdAssertions): avoid vm call for trivial conditions (#693)

aubBrooks919 · aubBrooks919 · commit 8c3081cc067d · 2025-07-31T13:23:19.000+02:00
Avoid calling vm when the condition is trivial to check inline. This is a minor performance improvement as a couple of opcodes execute a lot faster than a full cheatcode pipeline (external call, EVM call bookkeeping, abi encoding/decoding, ...) that eventually does nothing. For example, [Uniswap's v4-core](https://github.com/Uniswap/v4-core/) spends ~28% of the entire `forge test` CPU time in a couple of trivial `assert` functions (uint256, bytes32, true, false), ~13% for `forge coverage`. This is without accounting for the actual CALL/abi coding etc. These numbers are skewed due to profiling overhead, however making this change does have ~5% overall test performance improvement, for no compilation time change.
diff --git a/src/StdAssertions.sol b/src/StdAssertions.sol
@@ -49,35 +49,51 @@ abstract contract StdAssertions {
     }
 
     function assertTrue(bool data) internal pure virtual {
-        vm.assertTrue(data);
+        if (!data) {
+            vm.assertTrue(data);
+        }
     }
 
     function assertTrue(bool data, string memory err) internal pure virtual {
-        vm.assertTrue(data, err);
+        if (!data) {
+            vm.assertTrue(data, err);
+        }
     }
 
     function assertFalse(bool data) internal pure virtual {
-        vm.assertFalse(data);
+        if (data) {
+            vm.assertFalse(data);
+        }
     }
 
     function assertFalse(bool data, string memory err) internal pure virtual {
-        vm.assertFalse(data, err);
+        if (data) {
+            vm.assertFalse(data, err);
+        }
     }
 
     function assertEq(bool left, bool right) internal pure virtual {
-        vm.assertEq(left, right);
+        if (left != right) {
+            vm.assertEq(left, right);
+        }
     }
 
     function assertEq(bool left, bool right, string memory err) internal pure virtual {
-        vm.assertEq(left, right, err);
+        if (left != right) {
+            vm.assertEq(left, right, err);
+        }
     }
 
     function assertEq(uint256 left, uint256 right) internal pure virtual {
-        vm.assertEq(left, right);
+        if (left != right) {
+            vm.assertEq(left, right);
+        }
     }
 
     function assertEq(uint256 left, uint256 right, string memory err) internal pure virtual {
-        vm.assertEq(left, right, err);
+        if (left != right) {
+            vm.assertEq(left, right, err);
+        }
     }
 
     function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
@@ -89,11 +105,15 @@ abstract contract StdAssertions {
     }
 
     function assertEq(int256 left, int256 right) internal pure virtual {
-        vm.assertEq(left, right);
+        if (left != right) {
+            vm.assertEq(left, right);
+        }
     }
 
     function assertEq(int256 left, int256 right, string memory err) internal pure virtual {
-        vm.assertEq(left, right, err);
+        if (left != right) {
+            vm.assertEq(left, right, err);
+        }
     }
 
     function assertEqDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
@@ -105,27 +125,39 @@ abstract contract StdAssertions {
     }
 
     function assertEq(address left, address right) internal pure virtual {
-        vm.assertEq(left, right);
+        if (left != right) {
+            vm.assertEq(left, right);
+        }
     }
 
     function assertEq(address left, address right, string memory err) internal pure virtual {
-        vm.assertEq(left, right, err);
+        if (left != right) {
+            vm.assertEq(left, right, err);
+        }
     }
 
     function assertEq(bytes32 left, bytes32 right) internal pure virtual {
-        vm.assertEq(left, right);
+        if (left != right) {
+            vm.assertEq(left, right);
+        }
     }
 
     function assertEq(bytes32 left, bytes32 right, string memory err) internal pure virtual {
-        vm.assertEq(left, right, err);
+        if (left != right) {
+            vm.assertEq(left, right, err);
+        }
     }
 
     function assertEq32(bytes32 left, bytes32 right) internal pure virtual {
-        assertEq(left, right);
+        if (left != right) {
+            vm.assertEq(left, right);
+        }
     }
 
     function assertEq32(bytes32 left, bytes32 right, string memory err) internal pure virtual {
-        assertEq(left, right, err);
+        if (left != right) {
+            vm.assertEq(left, right, err);
+        }
     }
 
     function assertEq(string memory left, string memory right) internal pure virtual {
@@ -206,19 +238,27 @@ abstract contract StdAssertions {
     }
 
     function assertNotEq(bool left, bool right) internal pure virtual {
-        vm.assertNotEq(left, right);
+        if (left == right) {
+            vm.assertNotEq(left, right);
+        }
     }
 
     function assertNotEq(bool left, bool right, string memory err) internal pure virtual {
-        vm.assertNotEq(left, right, err);
+        if (left == right) {
+            vm.assertNotEq(left, right, err);
+        }
     }
 
     function assertNotEq(uint256 left, uint256 right) internal pure virtual {
-        vm.assertNotEq(left, right);
+        if (left == right) {
+            vm.assertNotEq(left, right);
+        }
     }
 
     function assertNotEq(uint256 left, uint256 right, string memory err) internal pure virtual {
-        vm.assertNotEq(left, right, err);
+        if (left == right) {
+            vm.assertNotEq(left, right, err);
+        }
     }
 
     function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
@@ -234,11 +274,15 @@ abstract contract StdAssertions {
     }
 
     function assertNotEq(int256 left, int256 right) internal pure virtual {
-        vm.assertNotEq(left, right);
+        if (left == right) {
+            vm.assertNotEq(left, right);
+        }
     }
 
     function assertNotEq(int256 left, int256 right, string memory err) internal pure virtual {
-        vm.assertNotEq(left, right, err);
+        if (left == right) {
+            vm.assertNotEq(left, right, err);
+        }
     }
 
     function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
@@ -250,27 +294,39 @@ abstract contract StdAssertions {
     }
 
     function assertNotEq(address left, address right) internal pure virtual {
-        vm.assertNotEq(left, right);
+        if (left == right) {
+            vm.assertNotEq(left, right);
+        }
     }
 
     function assertNotEq(address left, address right, string memory err) internal pure virtual {
-        vm.assertNotEq(left, right, err);
+        if (left == right) {
+            vm.assertNotEq(left, right, err);
+        }
     }
 
     function assertNotEq(bytes32 left, bytes32 right) internal pure virtual {
-        vm.assertNotEq(left, right);
+        if (left == right) {
+            vm.assertNotEq(left, right);
+        }
     }
 
     function assertNotEq(bytes32 left, bytes32 right, string memory err) internal pure virtual {
-        vm.assertNotEq(left, right, err);
+        if (left == right) {
+            vm.assertNotEq(left, right, err);
+        }
     }
 
     function assertNotEq32(bytes32 left, bytes32 right) internal pure virtual {
-        assertNotEq(left, right);
+        if (left == right) {
+            vm.assertNotEq(left, right);
+        }
     }
 
     function assertNotEq32(bytes32 left, bytes32 right, string memory err) internal pure virtual {
-        assertNotEq(left, right, err);
+        if (left == right) {
+            vm.assertNotEq(left, right, err);
+        }
     }
 
     function assertNotEq(string memory left, string memory right) internal pure virtual {
@@ -346,11 +402,15 @@ abstract contract StdAssertions {
     }
 
     function assertLt(uint256 left, uint256 right) internal pure virtual {
-        vm.assertLt(left, right);
+        if (!(left < right)) {
+            vm.assertLt(left, right);
+        }
     }
 
     function assertLt(uint256 left, uint256 right, string memory err) internal pure virtual {
-        vm.assertLt(left, right, err);
+        if (!(left < right)) {
+            vm.assertLt(left, right, err);
+        }
     }
 
     function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
@@ -362,11 +422,15 @@ abstract contract StdAssertions {
     }
 
     function assertLt(int256 left, int256 right) internal pure virtual {
-        vm.assertLt(left, right);
+        if (!(left < right)) {
+            vm.assertLt(left, right);
+        }
     }
 
     function assertLt(int256 left, int256 right, string memory err) internal pure virtual {
-        vm.assertLt(left, right, err);
+        if (!(left < right)) {
+            vm.assertLt(left, right, err);
+        }
     }
 
     function assertLtDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
@@ -378,11 +442,15 @@ abstract contract StdAssertions {
     }
 
     function assertGt(uint256 left, uint256 right) internal pure virtual {
-        vm.assertGt(left, right);
+        if (!(left > right)) {
+            vm.assertGt(left, right);
+        }
     }
 
     function assertGt(uint256 left, uint256 right, string memory err) internal pure virtual {
-        vm.assertGt(left, right, err);
+        if (!(left > right)) {
+            vm.assertGt(left, right, err);
+        }
     }
 
     function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
@@ -394,11 +462,15 @@ abstract contract StdAssertions {
     }
 
     function assertGt(int256 left, int256 right) internal pure virtual {
-        vm.assertGt(left, right);
+        if (!(left > right)) {
+            vm.assertGt(left, right);
+        }
     }
 
     function assertGt(int256 left, int256 right, string memory err) internal pure virtual {
-        vm.assertGt(left, right, err);
+        if (!(left > right)) {
+            vm.assertGt(left, right, err);
+        }
     }
 
     function assertGtDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
@@ -410,11 +482,15 @@ abstract contract StdAssertions {
     }
 
     function assertLe(uint256 left, uint256 right) internal pure virtual {
-        vm.assertLe(left, right);
+        if (!(left <= right)) {
+            vm.assertLe(left, right);
+        }
     }
 
     function assertLe(uint256 left, uint256 right, string memory err) internal pure virtual {
-        vm.assertLe(left, right, err);
+        if (!(left <= right)) {
+            vm.assertLe(left, right, err);
+        }
     }
 
     function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
@@ -426,11 +502,15 @@ abstract contract StdAssertions {
     }
 
     function assertLe(int256 left, int256 right) internal pure virtual {
-        vm.assertLe(left, right);
+        if (!(left <= right)) {
+            vm.assertLe(left, right);
+        }
     }
 
     function assertLe(int256 left, int256 right, string memory err) internal pure virtual {
-        vm.assertLe(left, right, err);
+        if (!(left <= right)) {
+            vm.assertLe(left, right, err);
+        }
     }
 
     function assertLeDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
@@ -442,11 +522,15 @@ abstract contract StdAssertions {
     }
 
     function assertGe(uint256 left, uint256 right) internal pure virtual {
-        vm.assertGe(left, right);
+        if (!(left >= right)) {
+            vm.assertGe(left, right);
+        }
     }
 
     function assertGe(uint256 left, uint256 right, string memory err) internal pure virtual {
-        vm.assertGe(left, right, err);
+        if (!(left >= right)) {
+            vm.assertGe(left, right, err);
+        }
     }
 
     function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
@@ -458,11 +542,15 @@ abstract contract StdAssertions {
     }
 
     function assertGe(int256 left, int256 right) internal pure virtual {
-        vm.assertGe(left, right);
+        if (!(left >= right)) {
+            vm.assertGe(left, right);
+        }
     }
 
     function assertGe(int256 left, int256 right, string memory err) internal pure virtual {
-        vm.assertGe(left, right, err);
+        if (!(left >= right)) {
+            vm.assertGe(left, right, err);
+        }
     }
 
     function assertGeDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {

Original file line number	Diff line number	Diff line change
`@@ -49,35 +49,51 @@ abstract contract StdAssertions {`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`function assertTrue(bool data) internal pure virtual {`
`52`		`- vm.assertTrue(data);`
	`52`	`+ if (!data) {`
	`53`	`+ vm.assertTrue(data);`
	`54`	`+ }`
`53`	`55`	`}`
`54`	`56`
`55`	`57`	`function assertTrue(bool data, string memory err) internal pure virtual {`
`56`		`- vm.assertTrue(data, err);`
	`58`	`+ if (!data) {`
	`59`	`+ vm.assertTrue(data, err);`
	`60`	`+ }`
`57`	`61`	`}`
`58`	`62`
`59`	`63`	`function assertFalse(bool data) internal pure virtual {`
`60`		`- vm.assertFalse(data);`
	`64`	`+ if (data) {`
	`65`	`+ vm.assertFalse(data);`
	`66`	`+ }`
`61`	`67`	`}`
`62`	`68`
`63`	`69`	`function assertFalse(bool data, string memory err) internal pure virtual {`
`64`		`- vm.assertFalse(data, err);`
	`70`	`+ if (data) {`
	`71`	`+ vm.assertFalse(data, err);`
	`72`	`+ }`
`65`	`73`	`}`
`66`	`74`
`67`	`75`	`function assertEq(bool left, bool right) internal pure virtual {`
`68`		`- vm.assertEq(left, right);`
	`76`	`+ if (left != right) {`
	`77`	`+ vm.assertEq(left, right);`
	`78`	`+ }`
`69`	`79`	`}`
`70`	`80`
`71`	`81`	`function assertEq(bool left, bool right, string memory err) internal pure virtual {`
`72`		`- vm.assertEq(left, right, err);`
	`82`	`+ if (left != right) {`
	`83`	`+ vm.assertEq(left, right, err);`
	`84`	`+ }`
`73`	`85`	`}`
`74`	`86`
`75`	`87`	`function assertEq(uint256 left, uint256 right) internal pure virtual {`
`76`		`- vm.assertEq(left, right);`
	`88`	`+ if (left != right) {`
	`89`	`+ vm.assertEq(left, right);`
	`90`	`+ }`
`77`	`91`	`}`
`78`	`92`
`79`	`93`	`function assertEq(uint256 left, uint256 right, string memory err) internal pure virtual {`
`80`		`- vm.assertEq(left, right, err);`
	`94`	`+ if (left != right) {`
	`95`	`+ vm.assertEq(left, right, err);`
	`96`	`+ }`
`81`	`97`	`}`
`82`	`98`
`83`	`99`	`function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {`
`@@ -89,11 +105,15 @@ abstract contract StdAssertions {`
`89`	`105`	`}`
`90`	`106`
`91`	`107`	`function assertEq(int256 left, int256 right) internal pure virtual {`
`92`		`- vm.assertEq(left, right);`
	`108`	`+ if (left != right) {`
	`109`	`+ vm.assertEq(left, right);`
	`110`	`+ }`
`93`	`111`	`}`
`94`	`112`
`95`	`113`	`function assertEq(int256 left, int256 right, string memory err) internal pure virtual {`
`96`		`- vm.assertEq(left, right, err);`
	`114`	`+ if (left != right) {`
	`115`	`+ vm.assertEq(left, right, err);`
	`116`	`+ }`
`97`	`117`	`}`
`98`	`118`
`99`	`119`	`function assertEqDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {`
`@@ -105,27 +125,39 @@ abstract contract StdAssertions {`
`105`	`125`	`}`
`106`	`126`
`107`	`127`	`function assertEq(address left, address right) internal pure virtual {`
`108`		`- vm.assertEq(left, right);`
	`128`	`+ if (left != right) {`
	`129`	`+ vm.assertEq(left, right);`
	`130`	`+ }`
`109`	`131`	`}`
`110`	`132`
`111`	`133`	`function assertEq(address left, address right, string memory err) internal pure virtual {`
`112`		`- vm.assertEq(left, right, err);`
	`134`	`+ if (left != right) {`
	`135`	`+ vm.assertEq(left, right, err);`
	`136`	`+ }`
`113`	`137`	`}`
`114`	`138`
`115`	`139`	`function assertEq(bytes32 left, bytes32 right) internal pure virtual {`
`116`		`- vm.assertEq(left, right);`
	`140`	`+ if (left != right) {`
	`141`	`+ vm.assertEq(left, right);`
	`142`	`+ }`
`117`	`143`	`}`
`118`	`144`
`119`	`145`	`function assertEq(bytes32 left, bytes32 right, string memory err) internal pure virtual {`
`120`		`- vm.assertEq(left, right, err);`
	`146`	`+ if (left != right) {`
	`147`	`+ vm.assertEq(left, right, err);`
	`148`	`+ }`
`121`	`149`	`}`
`122`	`150`
`123`	`151`	`function assertEq32(bytes32 left, bytes32 right) internal pure virtual {`
`124`		`- assertEq(left, right);`
	`152`	`+ if (left != right) {`
	`153`	`+ vm.assertEq(left, right);`
	`154`	`+ }`
`125`	`155`	`}`
`126`	`156`
`127`	`157`	`function assertEq32(bytes32 left, bytes32 right, string memory err) internal pure virtual {`
`128`		`- assertEq(left, right, err);`
	`158`	`+ if (left != right) {`
	`159`	`+ vm.assertEq(left, right, err);`
	`160`	`+ }`
`129`	`161`	`}`
`130`	`162`
`131`	`163`	`function assertEq(string memory left, string memory right) internal pure virtual {`
`@@ -206,19 +238,27 @@ abstract contract StdAssertions {`
`206`	`238`	`}`
`207`	`239`
`208`	`240`	`function assertNotEq(bool left, bool right) internal pure virtual {`
`209`		`- vm.assertNotEq(left, right);`
	`241`	`+ if (left == right) {`
	`242`	`+ vm.assertNotEq(left, right);`
	`243`	`+ }`
`210`	`244`	`}`
`211`	`245`
`212`	`246`	`function assertNotEq(bool left, bool right, string memory err) internal pure virtual {`
`213`		`- vm.assertNotEq(left, right, err);`
	`247`	`+ if (left == right) {`
	`248`	`+ vm.assertNotEq(left, right, err);`
	`249`	`+ }`
`214`	`250`	`}`
`215`	`251`
`216`	`252`	`function assertNotEq(uint256 left, uint256 right) internal pure virtual {`
`217`		`- vm.assertNotEq(left, right);`
	`253`	`+ if (left == right) {`
	`254`	`+ vm.assertNotEq(left, right);`
	`255`	`+ }`
`218`	`256`	`}`
`219`	`257`
`220`	`258`	`function assertNotEq(uint256 left, uint256 right, string memory err) internal pure virtual {`
`221`		`- vm.assertNotEq(left, right, err);`
	`259`	`+ if (left == right) {`
	`260`	`+ vm.assertNotEq(left, right, err);`
	`261`	`+ }`
`222`	`262`	`}`
`223`	`263`
`224`	`264`	`function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {`
`@@ -234,11 +274,15 @@ abstract contract StdAssertions {`
`234`	`274`	`}`
`235`	`275`
`236`	`276`	`function assertNotEq(int256 left, int256 right) internal pure virtual {`
`237`		`- vm.assertNotEq(left, right);`
	`277`	`+ if (left == right) {`
	`278`	`+ vm.assertNotEq(left, right);`
	`279`	`+ }`
`238`	`280`	`}`
`239`	`281`
`240`	`282`	`function assertNotEq(int256 left, int256 right, string memory err) internal pure virtual {`
`241`		`- vm.assertNotEq(left, right, err);`
	`283`	`+ if (left == right) {`
	`284`	`+ vm.assertNotEq(left, right, err);`
	`285`	`+ }`
`242`	`286`	`}`
`243`	`287`
`244`	`288`	`function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {`
`@@ -250,27 +294,39 @@ abstract contract StdAssertions {`
`250`	`294`	`}`
`251`	`295`
`252`	`296`	`function assertNotEq(address left, address right) internal pure virtual {`
`253`		`- vm.assertNotEq(left, right);`
	`297`	`+ if (left == right) {`
	`298`	`+ vm.assertNotEq(left, right);`
	`299`	`+ }`
`254`	`300`	`}`
`255`	`301`
`256`	`302`	`function assertNotEq(address left, address right, string memory err) internal pure virtual {`
`257`		`- vm.assertNotEq(left, right, err);`
	`303`	`+ if (left == right) {`
	`304`	`+ vm.assertNotEq(left, right, err);`
	`305`	`+ }`
`258`	`306`	`}`
`259`	`307`
`260`	`308`	`function assertNotEq(bytes32 left, bytes32 right) internal pure virtual {`
`261`		`- vm.assertNotEq(left, right);`
	`309`	`+ if (left == right) {`
	`310`	`+ vm.assertNotEq(left, right);`
	`311`	`+ }`
`262`	`312`	`}`
`263`	`313`
`264`	`314`	`function assertNotEq(bytes32 left, bytes32 right, string memory err) internal pure virtual {`
`265`		`- vm.assertNotEq(left, right, err);`
	`315`	`+ if (left == right) {`
	`316`	`+ vm.assertNotEq(left, right, err);`
	`317`	`+ }`
`266`	`318`	`}`
`267`	`319`
`268`	`320`	`function assertNotEq32(bytes32 left, bytes32 right) internal pure virtual {`
`269`		`- assertNotEq(left, right);`
	`321`	`+ if (left == right) {`
	`322`	`+ vm.assertNotEq(left, right);`
	`323`	`+ }`
`270`	`324`	`}`
`271`	`325`
`272`	`326`	`function assertNotEq32(bytes32 left, bytes32 right, string memory err) internal pure virtual {`
`273`		`- assertNotEq(left, right, err);`
	`327`	`+ if (left == right) {`
	`328`	`+ vm.assertNotEq(left, right, err);`
	`329`	`+ }`
`274`	`330`	`}`
`275`	`331`
`276`	`332`	`function assertNotEq(string memory left, string memory right) internal pure virtual {`
`@@ -346,11 +402,15 @@ abstract contract StdAssertions {`
`346`	`402`	`}`
`347`	`403`
`348`	`404`	`function assertLt(uint256 left, uint256 right) internal pure virtual {`
`349`		`- vm.assertLt(left, right);`
	`405`	`+ if (!(left < right)) {`
	`406`	`+ vm.assertLt(left, right);`
	`407`	`+ }`
`350`	`408`	`}`
`351`	`409`
`352`	`410`	`function assertLt(uint256 left, uint256 right, string memory err) internal pure virtual {`
`353`		`- vm.assertLt(left, right, err);`
	`411`	`+ if (!(left < right)) {`
	`412`	`+ vm.assertLt(left, right, err);`
	`413`	`+ }`
`354`	`414`	`}`
`355`	`415`
`356`	`416`	`function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {`
`@@ -362,11 +422,15 @@ abstract contract StdAssertions {`
`362`	`422`	`}`
`363`	`423`
`364`	`424`	`function assertLt(int256 left, int256 right) internal pure virtual {`
`365`		`- vm.assertLt(left, right);`
	`425`	`+ if (!(left < right)) {`
	`426`	`+ vm.assertLt(left, right);`
	`427`	`+ }`
`366`	`428`	`}`
`367`	`429`
`368`	`430`	`function assertLt(int256 left, int256 right, string memory err) internal pure virtual {`
`369`		`- vm.assertLt(left, right, err);`
	`431`	`+ if (!(left < right)) {`
	`432`	`+ vm.assertLt(left, right, err);`
	`433`	`+ }`
`370`	`434`	`}`
`371`	`435`
`372`	`436`	`function assertLtDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {`
`@@ -378,11 +442,15 @@ abstract contract StdAssertions {`
`378`	`442`	`}`
`379`	`443`
`380`	`444`	`function assertGt(uint256 left, uint256 right) internal pure virtual {`
`381`		`- vm.assertGt(left, right);`
	`445`	`+ if (!(left > right)) {`
	`446`	`+ vm.assertGt(left, right);`
	`447`	`+ }`
`382`	`448`	`}`
`383`	`449`
`384`	`450`	`function assertGt(uint256 left, uint256 right, string memory err) internal pure virtual {`
`385`		`- vm.assertGt(left, right, err);`
	`451`	`+ if (!(left > right)) {`
	`452`	`+ vm.assertGt(left, right, err);`
	`453`	`+ }`
`386`	`454`	`}`
`387`	`455`
`388`	`456`	`function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {`
`@@ -394,11 +462,15 @@ abstract contract StdAssertions {`
`394`	`462`	`}`
`395`	`463`
`396`	`464`	`function assertGt(int256 left, int256 right) internal pure virtual {`
`397`		`- vm.assertGt(left, right);`
	`465`	`+ if (!(left > right)) {`
	`466`	`+ vm.assertGt(left, right);`
	`467`	`+ }`
`398`	`468`	`}`
`399`	`469`
`400`	`470`	`function assertGt(int256 left, int256 right, string memory err) internal pure virtual {`
`401`		`- vm.assertGt(left, right, err);`
	`471`	`+ if (!(left > right)) {`
	`472`	`+ vm.assertGt(left, right, err);`
	`473`	`+ }`
`402`	`474`	`}`
`403`	`475`
`404`	`476`	`function assertGtDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {`
`@@ -410,11 +482,15 @@ abstract contract StdAssertions {`
`410`	`482`	`}`
`411`	`483`
`412`	`484`	`function assertLe(uint256 left, uint256 right) internal pure virtual {`
`413`		`- vm.assertLe(left, right);`
	`485`	`+ if (!(left <= right)) {`
	`486`	`+ vm.assertLe(left, right);`
	`487`	`+ }`
`414`	`488`	`}`
`415`	`489`
`416`	`490`	`function assertLe(uint256 left, uint256 right, string memory err) internal pure virtual {`
`417`		`- vm.assertLe(left, right, err);`
	`491`	`+ if (!(left <= right)) {`
	`492`	`+ vm.assertLe(left, right, err);`
	`493`	`+ }`
`418`	`494`	`}`
`419`	`495`
`420`	`496`	`function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {`
`@@ -426,11 +502,15 @@ abstract contract StdAssertions {`
`426`	`502`	`}`
`427`	`503`
`428`	`504`	`function assertLe(int256 left, int256 right) internal pure virtual {`
`429`		`- vm.assertLe(left, right);`
	`505`	`+ if (!(left <= right)) {`
	`506`	`+ vm.assertLe(left, right);`
	`507`	`+ }`
`430`	`508`	`}`
`431`	`509`
`432`	`510`	`function assertLe(int256 left, int256 right, string memory err) internal pure virtual {`
`433`		`- vm.assertLe(left, right, err);`
	`511`	`+ if (!(left <= right)) {`
	`512`	`+ vm.assertLe(left, right, err);`
	`513`	`+ }`
`434`	`514`	`}`
`435`	`515`
`436`	`516`	`function assertLeDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {`
`@@ -442,11 +522,15 @@ abstract contract StdAssertions {`
`442`	`522`	`}`
`443`	`523`
`444`	`524`	`function assertGe(uint256 left, uint256 right) internal pure virtual {`
`445`		`- vm.assertGe(left, right);`
	`525`	`+ if (!(left >= right)) {`
	`526`	`+ vm.assertGe(left, right);`
	`527`	`+ }`
`446`	`528`	`}`
`447`	`529`
`448`	`530`	`function assertGe(uint256 left, uint256 right, string memory err) internal pure virtual {`
`449`		`- vm.assertGe(left, right, err);`
	`531`	`+ if (!(left >= right)) {`
	`532`	`+ vm.assertGe(left, right, err);`
	`533`	`+ }`
`450`	`534`	`}`
`451`	`535`
`452`	`536`	`function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {`
`@@ -458,11 +542,15 @@ abstract contract StdAssertions {`
`458`	`542`	`}`
`459`	`543`
`460`	`544`	`function assertGe(int256 left, int256 right) internal pure virtual {`
`461`		`- vm.assertGe(left, right);`
	`545`	`+ if (!(left >= right)) {`
	`546`	`+ vm.assertGe(left, right);`
	`547`	`+ }`
`462`	`548`	`}`
`463`	`549`
`464`	`550`	`function assertGe(int256 left, int256 right, string memory err) internal pure virtual {`
`465`		`- vm.assertGe(left, right, err);`
	`551`	`+ if (!(left >= right)) {`
	`552`	`+ vm.assertGe(left, right, err);`
	`553`	`+ }`
`466`	`554`	`}`
`467`	`555`
`468`	`556`	`function assertGeDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {`