diff --git a/.gas-snapshot b/.gas-snapshot
index 7a7493e..9b8783b 100644
--- a/.gas-snapshot
+++ b/.gas-snapshot
@@ -1,7 +1,7 @@
-ArrayOpsTest:testConcat(uint256) (runs: 272, μ: 312877, ~: 57449)
-ArrayOpsTest:testFilled(uint256) (runs: 272, μ: 231481, ~: 37327)
-ArrayOpsTest:testZeroAddresses(uint256) (runs: 272, μ: 123150, ~: 27729)
-ArrayOpsTest:test__codesize() (gas: 4235)
+ArrayOpsTest:testConcat(uint256) (runs: 276, μ: 392279, ~: 62913)
+ArrayOpsTest:testFilled(uint256) (runs: 276, μ: 260423, ~: 38526)
+ArrayOpsTest:testZeroAddresses(uint256) (runs: 276, μ: 160090, ~: 27938)
+ArrayOpsTest:test__codesize() (gas: 4268)
 BenchTest:testMintAndTransferDN404_01() (gas: 208773)
 BenchTest:testMintAndTransferDN404_02() (gas: 214974)
 BenchTest:testMintAndTransferDN404_03() (gas: 221152)
@@ -66,153 +66,153 @@ BenchTest:testMintDN420_13() (gas: 111178)
 BenchTest:testMintDN420_14() (gas: 112563)
 BenchTest:testMintDN420_15() (gas: 114035)
 BenchTest:testMintDN420_16() (gas: 115441)
-BenchTest:test__codesize() (gas: 28527)
+BenchTest:test__codesize() (gas: 28596)
 DN404CustomUnitTest:testInitializeCorrectUnitSuccess() (gas: 129447)
 DN404CustomUnitTest:testInitializeWithUnitTooLargeReverts() (gas: 33803)
 DN404CustomUnitTest:testInitializeWithZeroUnitReverts() (gas: 13876)
 DN404CustomUnitTest:testMint() (gas: 162564)
-DN404CustomUnitTest:testMintWithoutNFTs(uint256,uint256,uint256) (runs: 272, μ: 160795, ~: 162075)
+DN404CustomUnitTest:testMintWithoutNFTs(uint256,uint256,uint256) (runs: 276, μ: 159607, ~: 162075)
 DN404CustomUnitTest:testNFTMint() (gas: 64872993)
-DN404CustomUnitTest:testNFTMintAndBurn(uint256,uint256,uint256) (runs: 272, μ: 203281, ~: 158442)
-DN404CustomUnitTest:testNFTMintViaTransfer(uint256,uint256,uint256) (runs: 272, μ: 231433, ~: 250252)
-DN404CustomUnitTest:testTotalSupplyOverflowsTrick(uint256,uint256) (runs: 272, μ: 608, ~: 664)
-DN404CustomUnitTest:testTotalSupplyOverflowsTrick(uint256,uint256,uint256) (runs: 272, μ: 786, ~: 746)
-DN404CustomUnitTest:testUnitInvalidCheckTrick(uint256) (runs: 272, μ: 526, ~: 527)
-DN404CustomUnitTest:test__codesize() (gas: 29372)
+DN404CustomUnitTest:testNFTMintAndBurn(uint256,uint256,uint256) (runs: 276, μ: 204015, ~: 158436)
+DN404CustomUnitTest:testNFTMintViaTransfer(uint256,uint256,uint256) (runs: 276, μ: 234977, ~: 250252)
+DN404CustomUnitTest:testTotalSupplyOverflowsTrick(uint256,uint256) (runs: 276, μ: 605, ~: 664)
+DN404CustomUnitTest:testTotalSupplyOverflowsTrick(uint256,uint256,uint256) (runs: 276, μ: 775, ~: 746)
+DN404CustomUnitTest:testUnitInvalidCheckTrick(uint256) (runs: 276, μ: 526, ~: 527)
+DN404CustomUnitTest:test__codesize() (gas: 29420)
 DN404MirrorTest:testBaseERC20() (gas: 114127)
 DN404MirrorTest:testFnSelectorNotRecognized() (gas: 6236)
 DN404MirrorTest:testLinkMirrorContract() (gas: 39444)
 DN404MirrorTest:testLogDirectTransfers() (gas: 395289)
 DN404MirrorTest:testLogTransfer() (gas: 120205)
-DN404MirrorTest:testNameAndSymbol(string,string) (runs: 272, μ: 205999, ~: 206402)
+DN404MirrorTest:testNameAndSymbol(string,string) (runs: 276, μ: 203093, ~: 206402)
 DN404MirrorTest:testNotLinked() (gas: 12777)
 DN404MirrorTest:testPullOwner() (gas: 112107)
-DN404MirrorTest:testPullOwnerWithOwnable() (gas: 3715317)
-DN404MirrorTest:testSafeTransferFrom(uint32) (runs: 272, μ: 478031, ~: 477986)
+DN404MirrorTest:testPullOwnerWithOwnable() (gas: 3720734)
+DN404MirrorTest:testSafeTransferFrom(uint32) (runs: 276, μ: 478042, ~: 477986)
 DN404MirrorTest:testSetAndGetApprovalForAll() (gas: 330334)
-DN404MirrorTest:testSetAndGetApproved() (gas: 327478)
+DN404MirrorTest:testSetAndGetApproved() (gas: 327479)
 DN404MirrorTest:testSupportsInterface() (gas: 7544)
-DN404MirrorTest:testTokenURI(string,uint256) (runs: 272, μ: 260853, ~: 265606)
-DN404MirrorTest:testTransferFrom(uint32) (runs: 272, μ: 379229, ~: 379184)
-DN404MirrorTest:testTransferFromMixed(uint256) (runs: 272, μ: 701276, ~: 616407)
-DN404MirrorTest:test__codesize() (gas: 59836)
+DN404MirrorTest:testTokenURI(string,uint256) (runs: 276, μ: 260276, ~: 265606)
+DN404MirrorTest:testTransferFrom(uint32) (runs: 276, μ: 379240, ~: 379184)
+DN404MirrorTest:testTransferFromMixed(uint256) (runs: 276, μ: 747704, ~: 675595)
+DN404MirrorTest:test__codesize() (gas: 59911)
 DN404OnlyERC20Test:testApprove() (gas: 35803)
-DN404OnlyERC20Test:testApprove(address,uint256) (runs: 272, μ: 30915, ~: 31354)
+DN404OnlyERC20Test:testApprove(address,uint256) (runs: 276, μ: 31281, ~: 31354)
 DN404OnlyERC20Test:testBurn() (gas: 48166)
-DN404OnlyERC20Test:testBurn(address,uint256,uint256) (runs: 272, μ: 49037, ~: 49345)
-DN404OnlyERC20Test:testBurnInsufficientBalanceReverts(address,uint256,uint256) (runs: 272, μ: 42168, ~: 42394)
-DN404OnlyERC20Test:testInfiniteApproveTransferFrom() (gas: 82820)
-DN404OnlyERC20Test:testMaxSupplyTrick(uint256) (runs: 272, μ: 541, ~: 541)
+DN404OnlyERC20Test:testBurn(address,uint256,uint256) (runs: 276, μ: 49028, ~: 49345)
+DN404OnlyERC20Test:testBurnInsufficientBalanceReverts(address,uint256,uint256) (runs: 276, μ: 42244, ~: 42394)
+DN404OnlyERC20Test:testInfiniteApproveTransferFrom() (gas: 82824)
+DN404OnlyERC20Test:testMaxSupplyTrick(uint256) (runs: 276, μ: 541, ~: 541)
 DN404OnlyERC20Test:testMetadata() (gas: 8962)
 DN404OnlyERC20Test:testMint() (gas: 44065)
 DN404OnlyERC20Test:testMintOverMaxLimitReverts() (gas: 42044)
-DN404OnlyERC20Test:testMintz(address,uint256) (runs: 272, μ: 44059, ~: 44487)
+DN404OnlyERC20Test:testMintz(address,uint256) (runs: 276, μ: 44560, ~: 44487)
 DN404OnlyERC20Test:testTransfer() (gas: 58082)
-DN404OnlyERC20Test:testTransfer(address,uint256) (runs: 272, μ: 58063, ~: 58491)
-DN404OnlyERC20Test:testTransferFrom() (gas: 79850)
-DN404OnlyERC20Test:testTransferFrom(address,address,address,uint256,uint256) (runs: 272, μ: 86950, ~: 88247)
+DN404OnlyERC20Test:testTransfer(address,uint256) (runs: 276, μ: 58564, ~: 58491)
+DN404OnlyERC20Test:testTransferFrom() (gas: 79853)
+DN404OnlyERC20Test:testTransferFrom(address,address,address,uint256,uint256) (runs: 276, μ: 86827, ~: 88251)
 DN404OnlyERC20Test:testTransferFromInsufficientAllowanceReverts() (gas: 66796)
-DN404OnlyERC20Test:testTransferFromInsufficientAllowanceReverts(address,uint256,uint256) (runs: 272, μ: 67708, ~: 67875)
+DN404OnlyERC20Test:testTransferFromInsufficientAllowanceReverts(address,uint256,uint256) (runs: 276, μ: 67765, ~: 67875)
 DN404OnlyERC20Test:testTransferFromInsufficientBalanceReverts() (gas: 51682)
-DN404OnlyERC20Test:testTransferFromInsufficientBalanceReverts(address,uint256,uint256) (runs: 272, μ: 52255, ~: 52465)
+DN404OnlyERC20Test:testTransferFromInsufficientBalanceReverts(address,uint256,uint256) (runs: 276, μ: 52313, ~: 52459)
 DN404OnlyERC20Test:testTransferInsufficientBalanceReverts() (gas: 43963)
-DN404OnlyERC20Test:testTransferInsufficientBalanceReverts(address,uint256,uint256) (runs: 272, μ: 44874, ~: 45072)
-DN404OnlyERC20Test:test__codesize() (gas: 28414)
+DN404OnlyERC20Test:testTransferInsufficientBalanceReverts(address,uint256,uint256) (runs: 276, μ: 44942, ~: 45072)
+DN404OnlyERC20Test:test__codesize() (gas: 28456)
 DN404Test:testBatchNFTLog() (gas: 326614)
-DN404Test:testBurnOnTransfer(uint32,address) (runs: 270, μ: 275204, ~: 275204)
+DN404Test:testBurnOnTransfer(uint32,address) (runs: 274, μ: 275195, ~: 275205)
 DN404Test:testFnSelectorNotRecognized() (gas: 6268)
-DN404Test:testInitialize(uint32,address) (runs: 272, μ: 110809, ~: 113114)
+DN404Test:testInitialize(uint32,address) (runs: 276, μ: 111752, ~: 113114)
 DN404Test:testMintAndBurn() (gas: 346149)
 DN404Test:testMintAndBurn2() (gas: 282706)
-DN404Test:testMintNext() (gas: 704765)
-DN404Test:testMintNextContiguous(uint256) (runs: 272, μ: 577105, ~: 538708)
-DN404Test:testMintOnTransfer(uint32,address) (runs: 270, μ: 289761, ~: 289761)
-DN404Test:testMixed(bytes32) (runs: 272, μ: 587945, ~: 521472)
-DN404Test:testNameAndSymbol(string,string) (runs: 272, μ: 205779, ~: 206182)
+DN404Test:testMintNext() (gas: 707127)
+DN404Test:testMintNextContiguous(uint256) (runs: 276, μ: 592236, ~: 535367)
+DN404Test:testMintOnTransfer(uint32,address) (runs: 274, μ: 289752, ~: 289762)
+DN404Test:testMixed(bytes32) (runs: 276, μ: 560104, ~: 502215)
+DN404Test:testNameAndSymbol(string,string) (runs: 276, μ: 202873, ~: 206182)
 DN404Test:testNumAliasesOverflowReverts() (gas: 40944)
 DN404Test:testOwnedIds() (gas: 360447)
-DN404Test:testOwnedIds(uint256) (runs: 272, μ: 265635, ~: 284463)
-DN404Test:testPermit2() (gas: 455657)
-DN404Test:testRegisterAndResolveAlias(address,address) (runs: 272, μ: 120117, ~: 120191)
-DN404Test:testSetAndGetAux(address,uint88) (runs: 272, μ: 21887, ~: 22272)
-DN404Test:testSetAndGetOperatorApprovals(address,address,bool) (runs: 272, μ: 129649, ~: 119846)
+DN404Test:testOwnedIds(uint256) (runs: 276, μ: 270710, ~: 284723)
+DN404Test:testPermit2() (gas: 455655)
+DN404Test:testRegisterAndResolveAlias(address,address) (runs: 276, μ: 120046, ~: 120191)
+DN404Test:testSetAndGetAux(address,uint88) (runs: 276, μ: 22024, ~: 22274)
+DN404Test:testSetAndGetOperatorApprovals(address,address,bool) (runs: 276, μ: 129651, ~: 119846)
 DN404Test:testSetAndGetSkipNFT() (gas: 708368)
-DN404Test:testTokenURI(string,uint256) (runs: 272, μ: 12997096, ~: 12997243)
+DN404Test:testTokenURI(string,uint256) (runs: 276, μ: 12997209, ~: 12974786)
 DN404Test:testTransferWithMirrorEvent() (gas: 410315)
 DN404Test:testTransfersAndBurns() (gas: 487732)
-DN404Test:testWrapAround(uint32,uint256) (runs: 272, μ: 393413, ~: 388595)
-DN404Test:test__codesize() (gas: 61620)
+DN404Test:testWrapAround(uint32,uint256) (runs: 276, μ: 392587, ~: 388779)
+DN404Test:test__codesize() (gas: 61668)
 DN404ZeroIndexedTest:testBatchNFTLog() (gas: 326053)
-DN404ZeroIndexedTest:testBurnOnTransfer(uint32,address) (runs: 270, μ: 255124, ~: 255124)
+DN404ZeroIndexedTest:testBurnOnTransfer(uint32,address) (runs: 274, μ: 255125, ~: 255125)
 DN404ZeroIndexedTest:testFnSelectorNotRecognized() (gas: 6268)
-DN404ZeroIndexedTest:testInitialize(uint32,address) (runs: 272, μ: 109048, ~: 113108)
+DN404ZeroIndexedTest:testInitialize(uint32,address) (runs: 276, μ: 111004, ~: 113108)
 DN404ZeroIndexedTest:testMintAndBurn() (gas: 343030)
 DN404ZeroIndexedTest:testMintAndBurn2() (gas: 280290)
-DN404ZeroIndexedTest:testMintNext() (gas: 701766)
-DN404ZeroIndexedTest:testMintNextContiguous(uint256) (runs: 272, μ: 568584, ~: 524801)
-DN404ZeroIndexedTest:testMintOnTransfer(uint32,address) (runs: 270, μ: 269727, ~: 269727)
-DN404ZeroIndexedTest:testMixed(bytes32) (runs: 272, μ: 564213, ~: 505534)
-DN404ZeroIndexedTest:testNameAndSymbol(string,string) (runs: 272, μ: 205728, ~: 206131)
+DN404ZeroIndexedTest:testMintNext() (gas: 704128)
+DN404ZeroIndexedTest:testMintNextContiguous(uint256) (runs: 276, μ: 565562, ~: 498537)
+DN404ZeroIndexedTest:testMintOnTransfer(uint32,address) (runs: 274, μ: 269728, ~: 269728)
+DN404ZeroIndexedTest:testMixed(bytes32) (runs: 276, μ: 528496, ~: 448826)
+DN404ZeroIndexedTest:testNameAndSymbol(string,string) (runs: 276, μ: 202822, ~: 206131)
 DN404ZeroIndexedTest:testNumAliasesOverflowReverts() (gas: 40944)
 DN404ZeroIndexedTest:testOwnedIds() (gas: 347336)
-DN404ZeroIndexedTest:testOwnedIds(uint256) (runs: 272, μ: 263381, ~: 286216)
-DN404ZeroIndexedTest:testPermit2() (gas: 455292)
-DN404ZeroIndexedTest:testRegisterAndResolveAlias(address,address) (runs: 272, μ: 120191, ~: 120191)
-DN404ZeroIndexedTest:testSetAndGetAux(address,uint88) (runs: 272, μ: 22004, ~: 22289)
-DN404ZeroIndexedTest:testSetAndGetOperatorApprovals(address,address,bool) (runs: 272, μ: 129643, ~: 119840)
+DN404ZeroIndexedTest:testOwnedIds(uint256) (runs: 276, μ: 266517, ~: 284119)
+DN404ZeroIndexedTest:testPermit2() (gas: 455290)
+DN404ZeroIndexedTest:testRegisterAndResolveAlias(address,address) (runs: 276, μ: 120118, ~: 120191)
+DN404ZeroIndexedTest:testSetAndGetAux(address,uint88) (runs: 276, μ: 22074, ~: 22290)
+DN404ZeroIndexedTest:testSetAndGetOperatorApprovals(address,address,bool) (runs: 276, μ: 129645, ~: 119840)
 DN404ZeroIndexedTest:testSetAndGetSkipNFT() (gas: 708390)
-DN404ZeroIndexedTest:testTokenURI(string,uint256) (runs: 272, μ: 156286, ~: 156433)
+DN404ZeroIndexedTest:testTokenURI(string,uint256) (runs: 276, μ: 156399, ~: 133976)
 DN404ZeroIndexedTest:testTransferWithMirrorEvent() (gas: 409821)
 DN404ZeroIndexedTest:testTransfersAndBurns() (gas: 485767)
-DN404ZeroIndexedTest:testWrapAround(uint32,uint256) (runs: 272, μ: 380053, ~: 387951)
-DN404ZeroIndexedTest:testWrapNFTIdEquivalence(uint256,uint256,bool) (runs: 272, μ: 1379, ~: 1418)
-DN404ZeroIndexedTest:test__codesize() (gas: 61415)
+DN404ZeroIndexedTest:testWrapAround(uint32,uint256) (runs: 276, μ: 375791, ~: 383090)
+DN404ZeroIndexedTest:testWrapNFTIdEquivalence(uint256,uint256,bool) (runs: 276, μ: 1376, ~: 1418)
+DN404ZeroIndexedTest:test__codesize() (gas: 61463)
 DN420OnlyERC20Test:testApprove() (gas: 35770)
-DN420OnlyERC20Test:testApprove(address,uint256) (runs: 272, μ: 30882, ~: 31321)
+DN420OnlyERC20Test:testApprove(address,uint256) (runs: 276, μ: 31248, ~: 31321)
 DN420OnlyERC20Test:testBurn() (gas: 49034)
-DN420OnlyERC20Test:testBurn(address,uint256,uint256) (runs: 272, μ: 49749, ~: 50213)
-DN420OnlyERC20Test:testBurnInsufficientBalanceReverts(address,uint256,uint256) (runs: 272, μ: 42930, ~: 43257)
+DN420OnlyERC20Test:testBurn(address,uint256,uint256) (runs: 276, μ: 49974, ~: 50213)
+DN420OnlyERC20Test:testBurnInsufficientBalanceReverts(address,uint256,uint256) (runs: 276, μ: 43198, ~: 43257)
 DN420OnlyERC20Test:testInfiniteApproveTransferFrom() (gas: 80265)
-DN420OnlyERC20Test:testMaxSupplyTrick(uint256) (runs: 272, μ: 541, ~: 541)
+DN420OnlyERC20Test:testMaxSupplyTrick(uint256) (runs: 276, μ: 541, ~: 541)
 DN420OnlyERC20Test:testMetadata() (gas: 9030)
 DN420OnlyERC20Test:testMint() (gas: 45003)
 DN420OnlyERC20Test:testMintOverMaxLimitReverts() (gas: 40544)
-DN420OnlyERC20Test:testMintz(address,uint256) (runs: 272, μ: 44998, ~: 45425)
+DN420OnlyERC20Test:testMintz(address,uint256) (runs: 276, μ: 45418, ~: 45425)
 DN420OnlyERC20Test:testTransfer() (gas: 54107)
-DN420OnlyERC20Test:testTransfer(address,uint256) (runs: 272, μ: 53952, ~: 54464)
+DN420OnlyERC20Test:testTransfer(address,uint256) (runs: 276, μ: 54387, ~: 54464)
 DN420OnlyERC20Test:testTransferFrom() (gas: 77806)
-DN420OnlyERC20Test:testTransferFrom(address,address,address,uint256,uint256) (runs: 272, μ: 84263, ~: 85693)
+DN420OnlyERC20Test:testTransferFrom(address,address,address,uint256,uint256) (runs: 276, μ: 84152, ~: 85693)
 DN420OnlyERC20Test:testTransferFromInsufficientAllowanceReverts() (gas: 67729)
-DN420OnlyERC20Test:testTransferFromInsufficientAllowanceReverts(address,uint256,uint256) (runs: 272, μ: 68568, ~: 68808)
+DN420OnlyERC20Test:testTransferFromInsufficientAllowanceReverts(address,uint256,uint256) (runs: 276, μ: 68788, ~: 68808)
 DN420OnlyERC20Test:testTransferFromInsufficientBalanceReverts() (gas: 52389)
-DN420OnlyERC20Test:testTransferFromInsufficientBalanceReverts(address,uint256,uint256) (runs: 272, μ: 52897, ~: 53176)
+DN420OnlyERC20Test:testTransferFromInsufficientBalanceReverts(address,uint256,uint256) (runs: 276, μ: 53102, ~: 53176)
 DN420OnlyERC20Test:testTransferInsufficientBalanceReverts() (gas: 42411)
-DN420OnlyERC20Test:testTransferInsufficientBalanceReverts(address,uint256,uint256) (runs: 272, μ: 43239, ~: 43520)
-DN420OnlyERC20Test:test__codesize() (gas: 25156)
-DN420Test:testERC1155Methods(uint256) (runs: 272, μ: 4397473, ~: 4132240)
-DN420Test:testERC1155MethodsSelfTransfers(uint256) (runs: 272, μ: 2573780, ~: 2729108)
-DN420Test:testFindOwnedIds() (gas: 2702597)
-DN420Test:testMintNext() (gas: 2233230)
-DN420Test:testMintToNonERC155RecipientReverts(uint256) (runs: 272, μ: 932101, ~: 812194)
-DN420Test:testMintToRevertingERC155RecipientReverts(uint256) (runs: 272, μ: 1449756, ~: 1047579)
-DN420Test:testMintToZeroReverts(uint256) (runs: 272, μ: 771884, ~: 676736)
-DN420Test:testMixed(uint256) (runs: 272, μ: 6082105, ~: 4384769)
-DN420Test:testSafeBatchTransferFromToERC1155Recipient(uint256) (runs: 272, μ: 2413615, ~: 2212856)
-DN420Test:testSafeTransferFromToERC1155Recipient(uint256) (runs: 272, μ: 1772980, ~: 1507194)
-DN420Test:testTransferFromToERC1155Recipient(uint256) (runs: 272, μ: 2919025, ~: 2906541)
-DN420Test:testTransferMixedReverts(uint256) (runs: 272, μ: 4011182, ~: 3431493)
-DN420Test:test__codesize() (gas: 66558)
-MappingsTest:testAddressPairMapSetAndGet(address[2],address[2],uint256,uint256) (runs: 272, μ: 47720, ~: 48233)
-MappingsTest:testBitmapSetAndGet(uint256) (runs: 272, μ: 471738, ~: 443619)
-MappingsTest:testBitmapSetAndGet(uint256,uint256,bool,bool) (runs: 272, μ: 25120, ~: 26154)
+DN420OnlyERC20Test:testTransferInsufficientBalanceReverts(address,uint256,uint256) (runs: 276, μ: 43480, ~: 43520)
+DN420OnlyERC20Test:test__codesize() (gas: 25183)
+DN420Test:testERC1155Methods(uint256) (runs: 276, μ: 4405953, ~: 4144225)
+DN420Test:testERC1155MethodsSelfTransfers(uint256) (runs: 276, μ: 2487686, ~: 2120228)
+DN420Test:testFindOwnedIds() (gas: 2710082)
+DN420Test:testMintNext() (gas: 2241678)
+DN420Test:testMintToNonERC155RecipientReverts(uint256) (runs: 276, μ: 857655, ~: 815190)
+DN420Test:testMintToRevertingERC155RecipientReverts(uint256) (runs: 276, μ: 1466844, ~: 1007800)
+DN420Test:testMintToZeroReverts(uint256) (runs: 276, μ: 773452, ~: 678527)
+DN420Test:testMixed(uint256) (runs: 276, μ: 6049045, ~: 4073905)
+DN420Test:testSafeBatchTransferFromToERC1155Recipient(uint256) (runs: 276, μ: 2297704, ~: 2216420)
+DN420Test:testSafeTransferFromToERC1155Recipient(uint256) (runs: 276, μ: 1785357, ~: 1509121)
+DN420Test:testTransferFromToERC1155Recipient(uint256) (runs: 276, μ: 2923825, ~: 2910911)
+DN420Test:testTransferMixedReverts(uint256) (runs: 276, μ: 4148865, ~: 3421880)
+DN420Test:test__codesize() (gas: 66586)
+MappingsTest:testAddressPairMapSetAndGet(address[2],address[2],uint256,uint256) (runs: 276, μ: 47728, ~: 48233)
+MappingsTest:testBitmapSetAndGet(uint256) (runs: 276, μ: 510379, ~: 502124)
+MappingsTest:testBitmapSetAndGet(uint256,uint256,bool,bool) (runs: 276, μ: 25431, ~: 26337)
 MappingsTest:testFindFirstUnset() (gas: 79749)
-MappingsTest:testFindFirstUnset(uint256) (runs: 272, μ: 323192, ~: 241275)
-MappingsTest:testRestrictNFTId(uint256) (runs: 272, μ: 340, ~: 341)
-MappingsTest:testSetOwnerAliasAndOwnedIndex(uint256,uint32,uint32) (runs: 272, μ: 23503, ~: 23538)
-MappingsTest:testStorageSlotsNoCollision(uint256,uint256,uint256,uint256) (runs: 272, μ: 26826, ~: 26742)
-MappingsTest:testUint32MapSetAndGet(uint256) (runs: 272, μ: 1346878, ~: 1445746)
-MappingsTest:testUint32MapSetAndGet(uint256,uint256,uint32,uint32) (runs: 272, μ: 44714, ~: 46049)
-MappingsTest:testWrapNFTIdWithOverflowCheck(uint256,uint256,uint256) (runs: 272, μ: 811, ~: 852)
+MappingsTest:testFindFirstUnset(uint256) (runs: 276, μ: 338865, ~: 256756)
+MappingsTest:testRestrictNFTId(uint256) (runs: 276, μ: 340, ~: 340)
+MappingsTest:testSetOwnerAliasAndOwnedIndex(uint256,uint32,uint32) (runs: 276, μ: 23497, ~: 23474)
+MappingsTest:testStorageSlotsNoCollision(uint256,uint256,uint256,uint256) (runs: 276, μ: 26839, ~: 26834)
+MappingsTest:testUint32MapSetAndGet(uint256) (runs: 276, μ: 1262417, ~: 1132801)
+MappingsTest:testUint32MapSetAndGet(uint256,uint256,uint32,uint32) (runs: 276, μ: 45240, ~: 46049)
+MappingsTest:testWrapNFTIdWithOverflowCheck(uint256,uint256,uint256) (runs: 276, μ: 825, ~: 852)
 MappingsTest:test__codesize() (gas: 6857)
 MaxUnitInvariant:invariantBurnedPoolLengthIsTailMinusHead() (runs: 10, calls: 150, reverts: 0)
 MaxUnitInvariant:invariantDN404BalanceSum() (runs: 10, calls: 150, reverts: 0)
@@ -221,16 +221,16 @@ MaxUnitInvariant:invariantMirrorAndBaseRemainImmutable() (runs: 10, calls: 150,
 MaxUnitInvariant:invariantNoUserOwnsInvalidToken() (runs: 10, calls: 150, reverts: 0)
 MaxUnitInvariant:invariantTotalReflectionIsValid() (runs: 10, calls: 150, reverts: 0)
 MaxUnitInvariant:invariantUserReflectionIsValid() (runs: 10, calls: 150, reverts: 0)
-MintTests:test_WhenAmountIsGreaterThan_MAX_SUPPLYOrMintMakesNFTTotalSupplyExceed_MAX_SUPPLY(uint256) (runs: 272, μ: 60730, ~: 61613)
-MintTests:test_WhenRecipientAddressHasSkipNFTEnabled(uint256) (runs: 272, μ: 85941, ~: 85942)
-MintTests:test_WhenRecipientIsAddress0(uint256) (runs: 272, μ: 31069, ~: 31139)
-MintTests:test_WhenRecipientsBalanceDifferenceIsNotUpTo1e18(uint256) (runs: 272, μ: 82901, ~: 83101)
-MintTests:test_WhenRecipientsBalanceDifferenceIsUpTo1e18OrAbove(uint256) (runs: 272, μ: 89438, ~: 89631)
-MintTests:test__codesize() (gas: 27932)
+MintTests:test_WhenAmountIsGreaterThan_MAX_SUPPLYOrMintMakesNFTTotalSupplyExceed_MAX_SUPPLY(uint256) (runs: 276, μ: 60639, ~: 61606)
+MintTests:test_WhenRecipientAddressHasSkipNFTEnabled(uint256) (runs: 276, μ: 85946, ~: 85935)
+MintTests:test_WhenRecipientIsAddress0(uint256) (runs: 276, μ: 31069, ~: 31139)
+MintTests:test_WhenRecipientsBalanceDifferenceIsNotUpTo1e18(uint256) (runs: 276, μ: 82946, ~: 83100)
+MintTests:test_WhenRecipientsBalanceDifferenceIsUpTo1e18OrAbove(uint256) (runs: 276, μ: 89452, ~: 89631)
+MintTests:test__codesize() (gas: 27980)
 NFTMintDN404Test:testAllowlistMint() (gas: 258866)
 NFTMintDN404Test:testMint() (gas: 231562)
 NFTMintDN404Test:testTotalSupplyReached() (gas: 628056918)
-NFTMintDN404Test:test__codesize() (gas: 22634)
+NFTMintDN404Test:test__codesize() (gas: 22676)
 NonMultipleUnitInvariant:invariantBurnedPoolLengthIsTailMinusHead() (runs: 10, calls: 150, reverts: 0)
 NonMultipleUnitInvariant:invariantDN404BalanceSum() (runs: 10, calls: 150, reverts: 0)
 NonMultipleUnitInvariant:invariantMirror721BalanceSum() (runs: 10, calls: 150, reverts: 0)
@@ -242,7 +242,7 @@ SimpleDN404Test:testMint() (gas: 49573)
 SimpleDN404Test:testName() (gas: 9134)
 SimpleDN404Test:testSymbol() (gas: 9132)
 SimpleDN404Test:testWithdraw() (gas: 20732)
-SimpleDN404Test:test__codesize() (gas: 18556)
+SimpleDN404Test:test__codesize() (gas: 18598)
 SoladyTest:test__codesize() (gas: 840)
 TestPlus:test__codesize() (gas: 406)
 WADUnitInvariant:invariantBurnedPoolLengthIsTailMinusHead() (runs: 10, calls: 150, reverts: 0)
diff --git a/src/DN404.sol b/src/DN404.sol
index 8ea3f0e..0e888f9 100644
--- a/src/DN404.sol
+++ b/src/DN404.sol
@@ -129,6 +129,11 @@ abstract contract DN404 {
     /// [Etherscan](https://etherscan.io/address/0x000000000022D473030F116dDEE9F6B43aC78BA3)
     address internal constant _PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
 
+    /// @dev The ZKsync Permit2 deployment.
+    /// If deploying on ZKsync or Abstract, override `_isPermit2(address)` to check against this too.
+    /// [Etherscan](https://era.zksync.network/address/0x0000000000225e31D15943971F47aD3022F714Fa)
+    address internal constant _ZKSYNC_PERMIT_2 = 0x0000000000225e31D15943971F47aD3022F714Fa;
+
     /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
     /*                          STORAGE                           */
     /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
@@ -364,7 +369,7 @@ abstract contract DN404 {
 
     /// @dev Returns the amount of tokens that `spender` can spend on behalf of `owner`.
     function allowance(address owner, address spender) public view returns (uint256) {
-        if (_givePermit2DefaultInfiniteAllowance() && spender == _PERMIT2) {
+        if (_givePermit2DefaultInfiniteAllowance() && _isPermit2(spender)) {
             uint8 flags = _getDN404Storage().addressData[owner].flags;
             if ((flags & _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG) == uint256(0)) {
                 return type(uint256).max;
@@ -418,7 +423,7 @@ abstract contract DN404 {
     function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
         Uint256Ref storage a = _ref(_getDN404Storage().allowance, from, msg.sender);
 
-        uint256 allowed = _givePermit2DefaultInfiniteAllowance() && msg.sender == _PERMIT2
+        uint256 allowed = _givePermit2DefaultInfiniteAllowance() && _isPermit2(msg.sender)
             && (_getDN404Storage().addressData[from].flags & _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG)
                 == uint256(0) ? type(uint256).max : a.value;
 
@@ -447,6 +452,12 @@ abstract contract DN404 {
         return false;
     }
 
+    /// @dev Returns checks if `sender` is the canonical Permit2 address.
+    /// If on ZKsync, override this function to check against `_ZKSYNC_PERMIT_2` as well.
+    function _isPermit2(address sender) internal view virtual returns (bool) {
+        return sender == _PERMIT2;
+    }
+
     /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
     /*                  INTERNAL MINT FUNCTIONS                   */
     /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
@@ -975,7 +986,7 @@ abstract contract DN404 {
     ///
     /// Emits a {Approval} event.
     function _approve(address owner, address spender, uint256 amount) internal virtual {
-        if (_givePermit2DefaultInfiniteAllowance() && spender == _PERMIT2) {
+        if (_givePermit2DefaultInfiniteAllowance() && _isPermit2(spender)) {
             _getDN404Storage().addressData[owner].flags |= _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG;
         }
         _ref(_getDN404Storage().allowance, owner, spender).value = amount;
@@ -1616,7 +1627,7 @@ abstract contract DN404 {
             result := mload(0x40)
             mstore(0x40, add(add(result, 0x20), shl(5, n)))
             mstore(result, n)
-            codecopy(add(result, 0x20), codesize(), shl(5, n))
+            calldatacopy(add(result, 0x20), calldatasize(), shl(5, n))
         }
     }
 
@@ -1641,7 +1652,7 @@ abstract contract DN404 {
     /// @dev Concatenates the arrays.
     function _concat(uint256[] memory a, uint256[] memory b)
         private
-        view
+        pure
         returns (uint256[] memory result)
     {
         uint256 aN = a.length;
@@ -1654,11 +1665,17 @@ abstract contract DN404 {
             if n {
                 result := mload(0x40)
                 mstore(result, n)
-                let o := add(result, 0x20)
-                mstore(0x40, add(o, shl(5, n)))
-                let aL := shl(5, aN)
-                pop(staticcall(gas(), 4, add(a, 0x20), aL, o, aL))
-                pop(staticcall(gas(), 4, add(b, 0x20), shl(5, bN), add(o, aL), shl(5, bN)))
+                function copy(dst_, src_, n_) -> _end {
+                    _end := add(dst_, shl(5, n_))
+                    if n_ {
+                        for { let d_ := sub(src_, dst_) } 1 {} {
+                            mstore(dst_, mload(add(dst_, d_)))
+                            dst_ := add(dst_, 0x20)
+                            if eq(dst_, _end) { break }
+                        }
+                    }
+                }
+                mstore(0x40, copy(copy(add(result, 0x20), add(a, 0x20), aN), add(b, 0x20), bN))
             }
         }
     }
@@ -1666,7 +1683,7 @@ abstract contract DN404 {
     /// @dev Concatenates the arrays.
     function _concat(address[] memory a, address[] memory b)
         private
-        view
+        pure
         returns (address[] memory result)
     {
         result = _toAddresses(_concat(_toUints(a), _toUints(b)));
diff --git a/src/DN404Mirror.sol b/src/DN404Mirror.sol
index 499f0ae..ddb1569 100644
--- a/src/DN404Mirror.sol
+++ b/src/DN404Mirror.sol
@@ -523,7 +523,15 @@ contract DN404Mirror {
             mstore(add(m, 0x80), 0x80)
             let n := mload(data)
             mstore(add(m, 0xa0), n)
-            if n { pop(staticcall(gas(), 4, add(data, 0x20), n, add(m, 0xc0), n)) }
+            if n {
+                let dst := add(m, 0xc0)
+                let end := add(dst, n)
+                for { let d := sub(add(data, 0x20), dst) } 1 {} {
+                    mstore(dst, mload(add(dst, d)))
+                    dst := add(dst, 0x20)
+                    if iszero(lt(dst, end)) { break }
+                }
+            }
             // Revert if the call reverts.
             if iszero(call(gas(), to, 0, add(m, 0x1c), add(n, 0xa4), m, 0x20)) {
                 if returndatasize() {
diff --git a/src/DN420.sol b/src/DN420.sol
index 50993df..a8bd6d5 100644
--- a/src/DN420.sol
+++ b/src/DN420.sol
@@ -177,6 +177,11 @@ abstract contract DN420 {
     /// [Etherscan](https://etherscan.io/address/0x000000000022D473030F116dDEE9F6B43aC78BA3)
     address internal constant _PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
 
+    /// @dev The ZKsync Permit2 deployment.
+    /// If deploying on ZKsync or Abstract, override `_isPermit2(address)` to check against this too.
+    /// [Etherscan](https://era.zksync.network/address/0x0000000000225e31D15943971F47aD3022F714Fa)
+    address internal constant _ZKSYNC_PERMIT_2 = 0x0000000000225e31D15943971F47aD3022F714Fa;
+
     /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
     /*                          STORAGE                           */
     /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
@@ -353,7 +358,7 @@ abstract contract DN420 {
 
     /// @dev Returns the amount of ERC20 tokens that `spender` can spend on behalf of `owner`.
     function allowance(address owner, address spender) public view returns (uint256) {
-        if (_givePermit2DefaultInfiniteAllowance() && spender == _PERMIT2) {
+        if (_givePermit2DefaultInfiniteAllowance() && _isPermit2(spender)) {
             uint8 flags = _getDN420Storage().addressData[owner].flags;
             if ((flags & _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG) == uint256(0)) {
                 return type(uint256).max;
@@ -410,7 +415,7 @@ abstract contract DN420 {
     function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
         Uint256Ref storage a = _ref(_getDN420Storage().allowance, from, msg.sender);
 
-        uint256 allowed = _givePermit2DefaultInfiniteAllowance() && msg.sender == _PERMIT2
+        uint256 allowed = _givePermit2DefaultInfiniteAllowance() && _isPermit2(msg.sender)
             && (_getDN420Storage().addressData[from].flags & _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG)
                 == uint256(0) ? type(uint256).max : a.value;
 
@@ -435,6 +440,12 @@ abstract contract DN420 {
         return false;
     }
 
+    /// @dev Returns checks if `sender` is the canonical Permit2 address.
+    /// If on ZKsync, override this function to check against `_ZKSYNC_PERMIT_2` as well.
+    function _isPermit2(address sender) internal view virtual returns (bool) {
+        return sender == _PERMIT2;
+    }
+
     /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
     /*                  INTERNAL MINT FUNCTIONS                   */
     /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
@@ -931,7 +942,7 @@ abstract contract DN420 {
     ///
     /// Emits a {Approval} event.
     function _approve(address owner, address spender, uint256 amount) internal virtual {
-        if (_givePermit2DefaultInfiniteAllowance() && spender == _PERMIT2) {
+        if (_givePermit2DefaultInfiniteAllowance() && _isPermit2(spender)) {
             _getDN420Storage().addressData[owner].flags |= _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG;
         }
         _ref(_getDN420Storage().allowance, owner, spender).value = amount;
@@ -1551,7 +1562,7 @@ abstract contract DN420 {
             result := mload(0x40)
             mstore(0x40, add(add(result, 0x20), shl(5, n)))
             mstore(result, n)
-            codecopy(add(result, 0x20), codesize(), shl(5, n))
+            calldatacopy(add(result, 0x20), calldatasize(), shl(5, n))
         }
     }
 
@@ -1576,7 +1587,7 @@ abstract contract DN420 {
     /// @dev Concatenates the arrays.
     function _concat(uint256[] memory a, uint256[] memory b)
         private
-        view
+        pure
         returns (uint256[] memory result)
     {
         uint256 aN = a.length;
@@ -1589,11 +1600,17 @@ abstract contract DN420 {
             if n {
                 result := mload(0x40)
                 mstore(result, n)
-                let o := add(result, 0x20)
-                mstore(0x40, add(o, shl(5, n)))
-                let aL := shl(5, aN)
-                pop(staticcall(gas(), 4, add(a, 0x20), aL, o, aL))
-                pop(staticcall(gas(), 4, add(b, 0x20), shl(5, bN), add(o, aL), shl(5, bN)))
+                function copy(dst_, src_, n_) -> _end {
+                    _end := add(dst_, shl(5, n_))
+                    if n_ {
+                        for { let d_ := sub(src_, dst_) } 1 {} {
+                            mstore(dst_, mload(add(dst_, d_)))
+                            dst_ := add(dst_, 0x20)
+                            if eq(dst_, _end) { break }
+                        }
+                    }
+                }
+                mstore(0x40, copy(copy(add(result, 0x20), add(a, 0x20), aN), add(b, 0x20), bN))
             }
         }
     }
@@ -1601,7 +1618,7 @@ abstract contract DN420 {
     /// @dev Concatenates the arrays.
     function _concat(address[] memory a, address[] memory b)
         private
-        view
+        pure
         returns (address[] memory result)
     {
         result = _toAddresses(_concat(_toUints(a), _toUints(b)));
diff --git a/test/ArrayOps.t.sol b/test/ArrayOps.t.sol
index ba96e26..c3ec5fb 100644
--- a/test/ArrayOps.t.sol
+++ b/test/ArrayOps.t.sol
@@ -14,7 +14,7 @@ contract ArrayOpsTest is SoladyTest {
             result := mload(0x40)
             mstore(0x40, add(add(result, 0x20), shl(5, n)))
             mstore(result, n)
-            codecopy(add(result, 0x20), codesize(), shl(5, n))
+            calldatacopy(add(result, 0x20), calldatasize(), shl(5, n))
         }
     }
 
@@ -39,7 +39,7 @@ contract ArrayOpsTest is SoladyTest {
     /// @dev Concatenates the arrays.
     function _concat(uint256[] memory a, uint256[] memory b)
         private
-        view
+        pure
         returns (uint256[] memory result)
     {
         uint256 aN = a.length;
@@ -52,11 +52,17 @@ contract ArrayOpsTest is SoladyTest {
             if n {
                 result := mload(0x40)
                 mstore(result, n)
-                let o := add(result, 0x20)
-                mstore(0x40, add(o, shl(5, n)))
-                let aL := shl(5, aN)
-                pop(staticcall(gas(), 4, add(a, 0x20), aL, o, aL))
-                pop(staticcall(gas(), 4, add(b, 0x20), shl(5, bN), add(o, aL), shl(5, bN)))
+                function copy(dst_, src_, n_) -> _end {
+                    _end := add(dst_, shl(5, n_))
+                    if n_ {
+                        for { let d_ := sub(src_, dst_) } 1 {} {
+                            mstore(dst_, mload(add(dst_, d_)))
+                            dst_ := add(dst_, 0x20)
+                            if eq(dst_, _end) { break }
+                        }
+                    }
+                }
+                mstore(0x40, copy(copy(add(result, 0x20), add(a, 0x20), aN), add(b, 0x20), bN))
             }
         }
     }
@@ -64,7 +70,7 @@ contract ArrayOpsTest is SoladyTest {
     /// @dev Concatenates the arrays.
     function _concat(address[] memory a, address[] memory b)
         private
-        view
+        pure
         returns (address[] memory result)
     {
         result = _toAddresses(_concat(_toUints(a), _toUints(b)));
@@ -176,4 +182,25 @@ contract ArrayOpsTest is SoladyTest {
             assertEq(concatenated, t.combined);
         }
     }
+
+    function testERC721ReceiverCheckCopy(bytes memory data) public {
+        bytes32 expected = keccak256(data);
+        bytes32 computed;
+        /// @solidity memory-safe-assembly
+        assembly {
+            let m := mload(0x40)
+            let n := mload(data)
+            if n {
+                let dst := add(m, 0xc0)
+                let end := add(dst, n)
+                for { let d := sub(add(data, 0x20), dst) } 1 {} {
+                    mstore(dst, mload(add(dst, d)))
+                    dst := add(dst, 0x20)
+                    if iszero(lt(dst, end)) { break }
+                }
+            }
+            computed := keccak256(add(m, 0xc0), n)
+        }
+        assertEq(computed, expected);
+    }
 }